json-model side-effects in testrun
April 4, 2024 · View on GitHub
When running tests json-model mutated either the original schema or the data being validated with the schema or both.
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalItems as schema, additional items match schema
Original schema
{
"items": [
{}
],
"additionalItems": {
"type": "integer"
}
}
Schema after validating
{
"items": [
{}
],
"additionalItems": {
"type": "integer"
},
"id": "6547574439078518anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalItems as schema, additional items do not match schema
Original schema
{
"items": [
{}
],
"additionalItems": {
"type": "integer"
}
}
Schema after validating
{
"items": [
{}
],
"additionalItems": {
"type": "integer"
},
"id": "6547574439078518anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items is schema, no additionalItems, all items match schema
Original schema
{
"items": {},
"additionalItems": false
}
Schema after validating
{
"items": {},
"additionalItems": false,
"id": "3507570247655525anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array of items with no additionalItems, empty array
Original schema
{
"items": [
{},
{},
{}
],
"additionalItems": false
}
Schema after validating
{
"items": [
{},
{},
{}
],
"additionalItems": false,
"id": "6020850410993199anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array of items with no additionalItems, fewer number of items present (1)
Original schema
{
"items": [
{},
{},
{}
],
"additionalItems": false
}
Schema after validating
{
"items": [
{},
{},
{}
],
"additionalItems": false,
"id": "6020850410993199anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array of items with no additionalItems, fewer number of items present (2)
Original schema
{
"items": [
{},
{},
{}
],
"additionalItems": false
}
Schema after validating
{
"items": [
{},
{},
{}
],
"additionalItems": false,
"id": "6020850410993199anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array of items with no additionalItems, equal number of items present
Original schema
{
"items": [
{},
{},
{}
],
"additionalItems": false
}
Schema after validating
{
"items": [
{},
{},
{}
],
"additionalItems": false,
"id": "6020850410993199anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array of items with no additionalItems, additional items are not permitted
Original schema
{
"items": [
{},
{},
{}
],
"additionalItems": false
}
Schema after validating
{
"items": [
{},
{},
{}
],
"additionalItems": false,
"id": "6020850410993199anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalItems as false without items, items defaults to empty schema so everything is valid
Original schema
{
"additionalItems": false
}
Schema after validating
{
"additionalItems": false,
"id": "9547431727467395anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalItems as false without items, ignores non-arrays
Original schema
{
"additionalItems": false
}
Schema after validating
{
"additionalItems": false,
"id": "9547431727467395anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalItems are allowed by default, only the first item is validated
Original schema
{
"items": [
{
"type": "integer"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer"
}
],
"id": "3790868591819647anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalItems should not look in applicators, valid case, items defined in allOf are not examined
Original schema
{
"allOf": [
{
"items": [
{
"type": "integer"
}
]
}
],
"additionalItems": {
"type": "boolean"
}
}
Schema after validating
{
"allOf": [
{
"items": [
{
"type": "integer"
}
]
}
],
"additionalItems": {
"type": "boolean"
},
"id": "9872080580539235anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalItems should not look in applicators, invalid case, items defined in allOf are not examined
Original schema
{
"allOf": [
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
],
"items": [
{
"type": "integer"
}
],
"additionalItems": {
"type": "boolean"
}
}
Schema after validating
{
"allOf": [
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
],
"items": [
{
"type": "integer"
}
],
"additionalItems": {
"type": "boolean"
},
"id": "5643751685435503anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties being false does not allow other properties, no additional properties is valid
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false,
"id": "7765261726619019anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties being false does not allow other properties, an additional property is invalid
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false,
"id": "7765261726619019anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties being false does not allow other properties, ignores arrays
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false,
"id": "7765261726619019anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties being false does not allow other properties, ignores strings
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false,
"id": "7765261726619019anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties being false does not allow other properties, ignores other non-objects
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false,
"id": "7765261726619019anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties being false does not allow other properties, patternProperties are not additional properties
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"patternProperties": {
"^v": {}
},
"additionalProperties": false,
"id": "7765261726619019anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test non-ASCII pattern with additionalProperties, matching the pattern is valid
Original schema
{
"patternProperties": {
"^á": {}
},
"additionalProperties": false
}
Schema after validating
{
"patternProperties": {
"^á": {}
},
"additionalProperties": false,
"id": "7817443155522674anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test non-ASCII pattern with additionalProperties, not matching the pattern is invalid
Original schema
{
"patternProperties": {
"^á": {}
},
"additionalProperties": false
}
Schema after validating
{
"patternProperties": {
"^á": {}
},
"additionalProperties": false,
"id": "7817443155522674anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties allows a schema which should validate, no additional properties is valid
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"additionalProperties": {
"type": "boolean"
}
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"additionalProperties": {
"type": "boolean"
},
"id": "42448596761293733anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties allows a schema which should validate, an additional valid property is valid
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"additionalProperties": {
"type": "boolean"
}
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"additionalProperties": {
"type": "boolean"
},
"id": "42448596761293733anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties allows a schema which should validate, an additional invalid property is invalid
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"additionalProperties": {
"type": "boolean"
}
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"additionalProperties": {
"type": "boolean"
},
"id": "42448596761293733anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties can exist by itself, an additional valid property is valid
Original schema
{
"additionalProperties": {
"type": "boolean"
}
}
Schema after validating
{
"additionalProperties": {
"type": "boolean"
},
"id": "12556773642085273anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties can exist by itself, an additional invalid property is invalid
Original schema
{
"additionalProperties": {
"type": "boolean"
}
}
Schema after validating
{
"additionalProperties": {
"type": "boolean"
},
"id": "12556773642085273anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties are allowed by default, additional properties are allowed
Original schema
{
"properties": {
"foo": {},
"bar": {}
}
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"id": "14498918203762878anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test additionalProperties should not look in applicators, properties defined in allOf are not examined
Original schema
{
"allOf": [
{
"properties": {
"foo": {}
}
}
],
"additionalProperties": {
"type": "boolean"
}
}
Schema after validating
{
"allOf": [
{
"properties": {
"foo": {}
}
}
],
"additionalProperties": {
"type": "boolean"
},
"id": "6430924691276234anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf, allOf
Original schema
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "0625775538990343anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf, mismatch second
Original schema
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "0625775538990343anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf, mismatch first
Original schema
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "0625775538990343anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf, wrong type
Original schema
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"allOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "0625775538990343anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with base schema, valid
Original schema
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
]
}
Schema after validating
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
],
"id": "1173891623799177anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with base schema, mismatch base schema
Original schema
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
]
}
Schema after validating
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
],
"id": "1173891623799177anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with base schema, mismatch first allOf
Original schema
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
]
}
Schema after validating
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
],
"id": "1173891623799177anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with base schema, mismatch second allOf
Original schema
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
]
}
Schema after validating
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
],
"id": "1173891623799177anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with base schema, mismatch both
Original schema
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
]
}
Schema after validating
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
],
"allOf": [
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
},
{
"properties": {
"baz": {
"type": "null"
}
},
"required": [
"baz"
]
}
],
"id": "1173891623799177anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf simple types, valid
Original schema
{
"allOf": [
{
"maximum": 30
},
{
"minimum": 20
}
]
}
Schema after validating
{
"allOf": [
{
"maximum": 30
},
{
"minimum": 20
}
],
"id": "8910819190020094anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf simple types, mismatch one
Original schema
{
"allOf": [
{
"maximum": 30
},
{
"minimum": 20
}
]
}
Schema after validating
{
"allOf": [
{
"maximum": 30
},
{
"minimum": 20
}
],
"id": "8910819190020094anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with boolean schemas, all false, any value is invalid
Original schema
{
"allOf": [
false,
false
]
}
Schema after validating
{
"allOf": [
false,
false
],
"id": "07016062779272447anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with one empty schema, any data is valid
Original schema
{
"allOf": [
{}
]
}
Schema after validating
{
"allOf": [
{}
],
"id": "7430344096878825anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with two empty schemas, any data is valid
Original schema
{
"allOf": [
{},
{}
]
}
Schema after validating
{
"allOf": [
{},
{}
],
"id": "3878783940056436anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with the first empty schema, number is valid
Original schema
{
"allOf": [
{},
{
"type": "number"
}
]
}
Schema after validating
{
"allOf": [
{},
{
"type": "number"
}
],
"id": "46709009024043713anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with the first empty schema, string is invalid
Original schema
{
"allOf": [
{},
{
"type": "number"
}
]
}
Schema after validating
{
"allOf": [
{},
{
"type": "number"
}
],
"id": "46709009024043713anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with the last empty schema, number is valid
Original schema
{
"allOf": [
{
"type": "number"
},
{}
]
}
Schema after validating
{
"allOf": [
{
"type": "number"
},
{}
],
"id": "5313878789634963anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf with the last empty schema, string is invalid
Original schema
{
"allOf": [
{
"type": "number"
},
{}
]
}
Schema after validating
{
"allOf": [
{
"type": "number"
},
{}
],
"id": "5313878789634963anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested allOf, to check validation semantics, null is valid
Original schema
{
"allOf": [
{
"allOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"allOf": [
{
"allOf": [
{
"type": "null"
}
]
}
],
"id": "3342006998508169anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested allOf, to check validation semantics, anything non-null is invalid
Original schema
{
"allOf": [
{
"allOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"allOf": [
{
"allOf": [
{
"type": "null"
}
]
}
],
"id": "3342006998508169anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: false, anyOf: false, oneOf: false
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: false, anyOf: false, oneOf: true
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: false, anyOf: true, oneOf: false
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: false, anyOf: true, oneOf: true
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: true, anyOf: false, oneOf: false
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: true, anyOf: false, oneOf: true
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: true, anyOf: true, oneOf: false
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test allOf combined with anyOf, oneOf, allOf: true, anyOf: true, oneOf: true
Original schema
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
]
}
Schema after validating
{
"allOf": [
{
"multipleOf": 2
}
],
"anyOf": [
{
"multipleOf": 3
}
],
"oneOf": [
{
"multipleOf": 5
}
],
"id": "582485590411211anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf, first anyOf valid
Original schema
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "18805658105692857anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf, second anyOf valid
Original schema
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "18805658105692857anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf, both anyOf valid
Original schema
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "18805658105692857anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf, neither anyOf valid
Original schema
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"anyOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "18805658105692857anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf with base schema, mismatch base schema
Original schema
{
"type": "string",
"anyOf": [
{
"maxLength": 2
},
{
"minLength": 4
}
]
}
Schema after validating
{
"type": "string",
"anyOf": [
{
"maxLength": 2
},
{
"minLength": 4
}
],
"id": "9320662373830362anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf with base schema, one anyOf valid
Original schema
{
"type": "string",
"anyOf": [
{
"maxLength": 2
},
{
"minLength": 4
}
]
}
Schema after validating
{
"type": "string",
"anyOf": [
{
"maxLength": 2
},
{
"minLength": 4
}
],
"id": "9320662373830362anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf with base schema, both anyOf invalid
Original schema
{
"type": "string",
"anyOf": [
{
"maxLength": 2
},
{
"minLength": 4
}
]
}
Schema after validating
{
"type": "string",
"anyOf": [
{
"maxLength": 2
},
{
"minLength": 4
}
],
"id": "9320662373830362anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf with boolean schemas, all false, any value is invalid
Original schema
{
"anyOf": [
false,
false
]
}
Schema after validating
{
"anyOf": [
false,
false
],
"id": "26593863509897164anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf complex types, first anyOf valid (complex)
Original schema
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "143523527999325anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf complex types, second anyOf valid (complex)
Original schema
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "143523527999325anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf complex types, both anyOf valid (complex)
Original schema
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "143523527999325anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf complex types, neither anyOf valid (complex)
Original schema
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"anyOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "143523527999325anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf with one empty schema, string is valid
Original schema
{
"anyOf": [
{
"type": "number"
},
{}
]
}
Schema after validating
{
"anyOf": [
{
"type": "number"
},
{}
],
"id": "9637921555301832anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test anyOf with one empty schema, number is valid
Original schema
{
"anyOf": [
{
"type": "number"
},
{}
]
}
Schema after validating
{
"anyOf": [
{
"type": "number"
},
{}
],
"id": "9637921555301832anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested anyOf, to check validation semantics, null is valid
Original schema
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
],
"id": "5570967628653816anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested anyOf, to check validation semantics, anything non-null is invalid
Original schema
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
],
"id": "5570967628653816anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested anyOf, to check validation semantics, null is valid
Original schema
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
],
"id": "049721671210464anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested anyOf, to check validation semantics, anything non-null is invalid
Original schema
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"anyOf": [
{
"anyOf": [
{
"type": "null"
}
]
}
],
"id": "049721671210464anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const validation, same value is valid
Original schema
{
"const": 2
}
Schema after validating
{
"const": 2,
"id": "9420404876407114anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const validation, another value is invalid
Original schema
{
"const": 2
}
Schema after validating
{
"const": 2,
"id": "9420404876407114anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const validation, another type is invalid
Original schema
{
"const": 2
}
Schema after validating
{
"const": 2,
"id": "9420404876407114anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with object, same object is valid
Original schema
{
"const": {
"foo": "bar",
"baz": "bax"
}
}
Schema after validating
{
"const": {
"foo": "bar",
"baz": "bax"
},
"id": "3564675219796509anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with object, same object with different property order is valid
Original schema
{
"const": {
"foo": "bar",
"baz": "bax"
}
}
Schema after validating
{
"const": {
"foo": "bar",
"baz": "bax"
},
"id": "3564675219796509anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with object, another object is invalid
Original schema
{
"const": {
"foo": "bar",
"baz": "bax"
}
}
Schema after validating
{
"const": {
"foo": "bar",
"baz": "bax"
},
"id": "3564675219796509anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with object, another type is invalid
Original schema
{
"const": {
"foo": "bar",
"baz": "bax"
}
}
Schema after validating
{
"const": {
"foo": "bar",
"baz": "bax"
},
"id": "3564675219796509anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with array, same array is valid
Original schema
{
"const": [
{
"foo": "bar"
}
]
}
Schema after validating
{
"const": [
{
"foo": "bar"
}
],
"id": "8780373682670839anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with array, another array item is invalid
Original schema
{
"const": [
{
"foo": "bar"
}
]
}
Schema after validating
{
"const": [
{
"foo": "bar"
}
],
"id": "8780373682670839anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with array, array with additional items is invalid
Original schema
{
"const": [
{
"foo": "bar"
}
]
}
Schema after validating
{
"const": [
{
"foo": "bar"
}
],
"id": "8780373682670839anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with null, null is valid
Original schema
{
"const": null
}
Schema after validating
{
"const": null,
"id": "823448826230881anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with null, not null is invalid
Original schema
{
"const": null
}
Schema after validating
{
"const": null,
"id": "823448826230881anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with false does not match 0, false is valid
Original schema
{
"const": false
}
Schema after validating
{
"const": false,
"id": "7262899334977986anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with false does not match 0, integer zero is invalid
Original schema
{
"const": false
}
Schema after validating
{
"const": false,
"id": "7262899334977986anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with false does not match 0, float zero is invalid
Original schema
{
"const": false
}
Schema after validating
{
"const": false,
"id": "7262899334977986anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with true does not match 1, true is valid
Original schema
{
"const": true
}
Schema after validating
{
"const": true,
"id": "6042073897820728anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with true does not match 1, integer one is invalid
Original schema
{
"const": true
}
Schema after validating
{
"const": true,
"id": "6042073897820728anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with true does not match 1, float one is invalid
Original schema
{
"const": true
}
Schema after validating
{
"const": true,
"id": "6042073897820728anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with [false] does not match [0], [false] is valid
Original schema
{
"const": [
false
]
}
Schema after validating
{
"const": [
false
],
"id": "25417558957043473anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with [false] does not match [0], [0] is invalid
Original schema
{
"const": [
false
]
}
Schema after validating
{
"const": [
false
],
"id": "25417558957043473anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with [false] does not match [0], [0.0] is invalid
Original schema
{
"const": [
false
]
}
Schema after validating
{
"const": [
false
],
"id": "25417558957043473anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with [true] does not match [1], [true] is valid
Original schema
{
"const": [
true
]
}
Schema after validating
{
"const": [
true
],
"id": "8828292161879758anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with [true] does not match [1], [1] is invalid
Original schema
{
"const": [
true
]
}
Schema after validating
{
"const": [
true
],
"id": "8828292161879758anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with [true] does not match [1], [1.0] is invalid
Original schema
{
"const": [
true
]
}
Schema after validating
{
"const": [
true
],
"id": "8828292161879758anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with {"a": false} does not match {"a": 0}, {"a": false} is valid
Original schema
{
"const": {
"a": false
}
}
Schema after validating
{
"const": {
"a": false
},
"id": "8292586167129194anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with {"a": false} does not match {"a": 0}, {"a": 0} is invalid
Original schema
{
"const": {
"a": false
}
}
Schema after validating
{
"const": {
"a": false
},
"id": "8292586167129194anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with {"a": false} does not match {"a": 0}, {"a": 0.0} is invalid
Original schema
{
"const": {
"a": false
}
}
Schema after validating
{
"const": {
"a": false
},
"id": "8292586167129194anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with {"a": true} does not match {"a": 1}, {"a": true} is valid
Original schema
{
"const": {
"a": true
}
}
Schema after validating
{
"const": {
"a": true
},
"id": "2840004558657472anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with {"a": true} does not match {"a": 1}, {"a": 1} is invalid
Original schema
{
"const": {
"a": true
}
}
Schema after validating
{
"const": {
"a": true
},
"id": "2840004558657472anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with {"a": true} does not match {"a": 1}, {"a": 1.0} is invalid
Original schema
{
"const": {
"a": true
}
}
Schema after validating
{
"const": {
"a": true
},
"id": "2840004558657472anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 0 does not match other zero-like types, false is invalid
Original schema
{
"const": 0
}
Schema after validating
{
"const": 0,
"id": "1562575944667164anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 0 does not match other zero-like types, integer zero is valid
Original schema
{
"const": 0
}
Schema after validating
{
"const": 0,
"id": "1562575944667164anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 0 does not match other zero-like types, float zero is valid
Original schema
{
"const": 0
}
Schema after validating
{
"const": 0,
"id": "1562575944667164anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 0 does not match other zero-like types, empty object is invalid
Original schema
{
"const": 0
}
Schema after validating
{
"const": 0,
"id": "1562575944667164anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 0 does not match other zero-like types, empty array is invalid
Original schema
{
"const": 0
}
Schema after validating
{
"const": 0,
"id": "1562575944667164anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 0 does not match other zero-like types, empty string is invalid
Original schema
{
"const": 0
}
Schema after validating
{
"const": 0,
"id": "1562575944667164anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 1 does not match true, true is invalid
Original schema
{
"const": 1
}
Schema after validating
{
"const": 1,
"id": "7774202412420872anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 1 does not match true, integer one is valid
Original schema
{
"const": 1
}
Schema after validating
{
"const": 1,
"id": "7774202412420872anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with 1 does not match true, float one is valid
Original schema
{
"const": 1
}
Schema after validating
{
"const": 1,
"id": "7774202412420872anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with -2.0 matches integer and float types, integer -2 is valid
Original schema
{
"const": -2
}
Schema after validating
{
"const": -2,
"id": "39131504816795726anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with -2.0 matches integer and float types, integer 2 is invalid
Original schema
{
"const": -2
}
Schema after validating
{
"const": -2,
"id": "39131504816795726anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with -2.0 matches integer and float types, float -2.0 is valid
Original schema
{
"const": -2
}
Schema after validating
{
"const": -2,
"id": "39131504816795726anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with -2.0 matches integer and float types, float 2.0 is invalid
Original schema
{
"const": -2
}
Schema after validating
{
"const": -2,
"id": "39131504816795726anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test const with -2.0 matches integer and float types, float -2.00001 is invalid
Original schema
{
"const": -2
}
Schema after validating
{
"const": -2,
"id": "39131504816795726anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test float and integers are equal up to 64-bit representation limits, integer is valid
Original schema
{
"const": 9007199254740992
}
Schema after validating
{
"const": 9007199254740992,
"id": "36582231454471636anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test float and integers are equal up to 64-bit representation limits, integer minus one is invalid
Original schema
{
"const": 9007199254740992
}
Schema after validating
{
"const": 9007199254740992,
"id": "36582231454471636anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test float and integers are equal up to 64-bit representation limits, float is valid
Original schema
{
"const": 9007199254740992
}
Schema after validating
{
"const": 9007199254740992,
"id": "36582231454471636anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test float and integers are equal up to 64-bit representation limits, float minus one is invalid
Original schema
{
"const": 9007199254740992
}
Schema after validating
{
"const": 9007199254740992,
"id": "36582231454471636anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nul characters in strings, match string with nul
Original schema
{
"const": "hello\u0000there"
}
Schema after validating
{
"const": "hello\u0000there",
"id": "19258320740209567anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nul characters in strings, do not match string lacking nul
Original schema
{
"const": "hello\u0000there"
}
Schema after validating
{
"const": "hello\u0000there",
"id": "19258320740209567anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword validation, array with item matching schema (5) is valid
Original schema
{
"contains": {
"minimum": 5
}
}
Schema after validating
{
"contains": {
"minimum": 5
},
"id": "1505393136215858anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword validation, array with item matching schema (6) is valid
Original schema
{
"contains": {
"minimum": 5
}
}
Schema after validating
{
"contains": {
"minimum": 5
},
"id": "1505393136215858anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword validation, array with two items matching schema (5, 6) is valid
Original schema
{
"contains": {
"minimum": 5
}
}
Schema after validating
{
"contains": {
"minimum": 5
},
"id": "1505393136215858anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword validation, array without items matching schema is invalid
Original schema
{
"contains": {
"minimum": 5
}
}
Schema after validating
{
"contains": {
"minimum": 5
},
"id": "1505393136215858anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword validation, empty array is invalid
Original schema
{
"contains": {
"minimum": 5
}
}
Schema after validating
{
"contains": {
"minimum": 5
},
"id": "1505393136215858anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword validation, not array is valid
Original schema
{
"contains": {
"minimum": 5
}
}
Schema after validating
{
"contains": {
"minimum": 5
},
"id": "1505393136215858anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with const keyword, array with item 5 is valid
Original schema
{
"contains": {
"const": 5
}
}
Schema after validating
{
"contains": {
"const": 5
},
"id": "03545893674755485anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with const keyword, array with two items 5 is valid
Original schema
{
"contains": {
"const": 5
}
}
Schema after validating
{
"contains": {
"const": 5
},
"id": "03545893674755485anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with const keyword, array without item 5 is invalid
Original schema
{
"contains": {
"const": 5
}
}
Schema after validating
{
"contains": {
"const": 5
},
"id": "03545893674755485anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with boolean schema true, any non-empty array is valid
Original schema
{
"contains": true
}
Schema after validating
{
"contains": true,
"id": "07854750543230482anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with boolean schema true, empty array is invalid
Original schema
{
"contains": true
}
Schema after validating
{
"contains": true,
"id": "07854750543230482anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with boolean schema false, any non-empty array is invalid
Original schema
{
"contains": false
}
Schema after validating
{
"contains": false,
"id": "1769277082117544anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with boolean schema false, empty array is invalid
Original schema
{
"contains": false
}
Schema after validating
{
"contains": false,
"id": "1769277082117544anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test contains keyword with boolean schema false, non-arrays are valid
Original schema
{
"contains": false
}
Schema after validating
{
"contains": false,
"id": "1769277082117544anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items + contains, matches items, does not match contains
Original schema
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
}
}
Schema after validating
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
},
"id": "039154195849823825anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items + contains, does not match items, matches contains
Original schema
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
}
}
Schema after validating
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
},
"id": "039154195849823825anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items + contains, matches both items and contains
Original schema
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
}
}
Schema after validating
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
},
"id": "039154195849823825anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items + contains, matches neither items nor contains
Original schema
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
}
}
Schema after validating
{
"items": {
"multipleOf": 2
},
"contains": {
"multipleOf": 3
},
"id": "039154195849823825anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test invalid type for default, valid when property is specified
Original schema
{
"properties": {
"foo": {
"type": "integer",
"default": []
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer",
"default": []
}
},
"id": "6673563186103502anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test invalid type for default, still valid when the invalid default is used
Original schema
{
"properties": {
"foo": {
"type": "integer",
"default": []
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer",
"default": []
}
},
"id": "6673563186103502anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test invalid string value for default, valid when property is specified
Original schema
{
"properties": {
"bar": {
"type": "string",
"minLength": 4,
"default": "bad"
}
}
}
Schema after validating
{
"properties": {
"bar": {
"type": "string",
"minLength": 4,
"default": "bad"
}
},
"id": "14990002222173038anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test invalid string value for default, still valid when the invalid default is used
Original schema
{
"properties": {
"bar": {
"type": "string",
"minLength": 4,
"default": "bad"
}
}
}
Schema after validating
{
"properties": {
"bar": {
"type": "string",
"minLength": 4,
"default": "bad"
}
},
"id": "14990002222173038anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test invalid definition, invalid definition schema
Original schema
{
"$ref": "http://json-schema.org/draft-07/schema#"
}
Schema after validating
{
"$ref": "http://json-schema.org/draft-07/schema#",
"id": "5202484898834405anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies, neither
Original schema
{
"dependencies": {
"bar": [
"foo"
]
}
}
Schema after validating
{
"dependencies": {
"bar": [
"foo"
]
},
"id": "9068596859354154anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies, nondependant
Original schema
{
"dependencies": {
"bar": [
"foo"
]
}
}
Schema after validating
{
"dependencies": {
"bar": [
"foo"
]
},
"id": "9068596859354154anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies, with dependency
Original schema
{
"dependencies": {
"bar": [
"foo"
]
}
}
Schema after validating
{
"dependencies": {
"bar": [
"foo"
]
},
"id": "9068596859354154anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies, missing dependency
Original schema
{
"dependencies": {
"bar": [
"foo"
]
}
}
Schema after validating
{
"dependencies": {
"bar": [
"foo"
]
},
"id": "9068596859354154anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies, ignores arrays
Original schema
{
"dependencies": {
"bar": [
"foo"
]
}
}
Schema after validating
{
"dependencies": {
"bar": [
"foo"
]
},
"id": "9068596859354154anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies, ignores strings
Original schema
{
"dependencies": {
"bar": [
"foo"
]
}
}
Schema after validating
{
"dependencies": {
"bar": [
"foo"
]
},
"id": "9068596859354154anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies, ignores other non-objects
Original schema
{
"dependencies": {
"bar": [
"foo"
]
}
}
Schema after validating
{
"dependencies": {
"bar": [
"foo"
]
},
"id": "9068596859354154anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with empty array, empty object
Original schema
{
"dependencies": {
"bar": []
}
}
Schema after validating
{
"dependencies": {
"bar": []
},
"id": "7594800812176634anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with empty array, object with one property
Original schema
{
"dependencies": {
"bar": []
}
}
Schema after validating
{
"dependencies": {
"bar": []
},
"id": "7594800812176634anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with empty array, non-object is valid
Original schema
{
"dependencies": {
"bar": []
}
}
Schema after validating
{
"dependencies": {
"bar": []
},
"id": "7594800812176634anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies, neither
Original schema
{
"dependencies": {
"quux": [
"foo",
"bar"
]
}
}
Schema after validating
{
"dependencies": {
"quux": [
"foo",
"bar"
]
},
"id": "9459924513469613anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies, nondependants
Original schema
{
"dependencies": {
"quux": [
"foo",
"bar"
]
}
}
Schema after validating
{
"dependencies": {
"quux": [
"foo",
"bar"
]
},
"id": "9459924513469613anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies, with dependencies
Original schema
{
"dependencies": {
"quux": [
"foo",
"bar"
]
}
}
Schema after validating
{
"dependencies": {
"quux": [
"foo",
"bar"
]
},
"id": "9459924513469613anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies, missing dependency
Original schema
{
"dependencies": {
"quux": [
"foo",
"bar"
]
}
}
Schema after validating
{
"dependencies": {
"quux": [
"foo",
"bar"
]
},
"id": "9459924513469613anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies, missing other dependency
Original schema
{
"dependencies": {
"quux": [
"foo",
"bar"
]
}
}
Schema after validating
{
"dependencies": {
"quux": [
"foo",
"bar"
]
},
"id": "9459924513469613anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies, missing both dependencies
Original schema
{
"dependencies": {
"quux": [
"foo",
"bar"
]
}
}
Schema after validating
{
"dependencies": {
"quux": [
"foo",
"bar"
]
},
"id": "9459924513469613anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies subschema, valid
Original schema
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
}
}
Schema after validating
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
},
"id": "34086411027783625anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies subschema, no dependency
Original schema
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
}
}
Schema after validating
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
},
"id": "34086411027783625anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies subschema, wrong type
Original schema
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
}
}
Schema after validating
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
},
"id": "34086411027783625anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies subschema, wrong type other
Original schema
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
}
}
Schema after validating
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
},
"id": "34086411027783625anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple dependencies subschema, wrong type both
Original schema
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
}
}
Schema after validating
{
"dependencies": {
"bar": {
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "integer"
}
}
}
},
"id": "34086411027783625anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with escaped characters, valid object 1
Original schema
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
}
}
Schema after validating
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
},
"id": "7071419134188879anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with escaped characters, valid object 2
Original schema
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
}
}
Schema after validating
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
},
"id": "7071419134188879anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with escaped characters, valid object 3
Original schema
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
}
}
Schema after validating
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
},
"id": "7071419134188879anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with escaped characters, invalid object 1
Original schema
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
}
}
Schema after validating
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
},
"id": "7071419134188879anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with escaped characters, invalid object 2
Original schema
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
}
}
Schema after validating
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
},
"id": "7071419134188879anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with escaped characters, invalid object 3
Original schema
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
}
}
Schema after validating
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
},
"id": "7071419134188879anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test dependencies with escaped characters, invalid object 4
Original schema
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
}
}
Schema after validating
{
"dependencies": {
"foo\nbar": [
"foo\rbar"
],
"foo\tbar": {
"minProperties": 4
},
"foo'bar": {
"required": [
"foo\"bar"
]
},
"foo\"bar": [
"foo'bar"
]
},
"id": "7071419134188879anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test simple enum validation, one of the enum is valid
Original schema
{
"enum": [
1,
2,
3
]
}
Schema after validating
{
"enum": [
1,
2,
3
],
"id": "32997802498394724anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test simple enum validation, something else is invalid
Original schema
{
"enum": [
1,
2,
3
]
}
Schema after validating
{
"enum": [
1,
2,
3
],
"id": "32997802498394724anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum validation, one of the enum is valid
Original schema
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
]
}
Schema after validating
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
],
"id": "5556923669057201anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum validation, something else is invalid
Original schema
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
]
}
Schema after validating
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
],
"id": "5556923669057201anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum validation, objects are deep compared
Original schema
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
]
}
Schema after validating
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
],
"id": "5556923669057201anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum validation, valid object matches
Original schema
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
]
}
Schema after validating
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
],
"id": "5556923669057201anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum validation, extra properties in object is invalid
Original schema
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
]
}
Schema after validating
{
"enum": [
6,
"foo",
[],
true,
{
"foo": 12
}
],
"id": "5556923669057201anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum-with-null validation, null is valid
Original schema
{
"enum": [
6,
null
]
}
Schema after validating
{
"enum": [
6,
null
],
"id": "7511413220527976anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum-with-null validation, number is valid
Original schema
{
"enum": [
6,
null
]
}
Schema after validating
{
"enum": [
6,
null
],
"id": "7511413220527976anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test heterogeneous enum-with-null validation, something else is invalid
Original schema
{
"enum": [
6,
null
]
}
Schema after validating
{
"enum": [
6,
null
],
"id": "7511413220527976anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enums in properties, both properties are valid
Original schema
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
]
}
Schema after validating
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
],
"id": "12339869961624195anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enums in properties, wrong foo value
Original schema
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
]
}
Schema after validating
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
],
"id": "12339869961624195anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enums in properties, wrong bar value
Original schema
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
]
}
Schema after validating
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
],
"id": "12339869961624195anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enums in properties, missing optional property is valid
Original schema
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
]
}
Schema after validating
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
],
"id": "12339869961624195anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enums in properties, missing required property is invalid
Original schema
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
]
}
Schema after validating
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
],
"id": "12339869961624195anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enums in properties, missing all properties is invalid
Original schema
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
]
}
Schema after validating
{
"type": "object",
"properties": {
"foo": {
"enum": [
"foo"
]
},
"bar": {
"enum": [
"bar"
]
}
},
"required": [
"bar"
],
"id": "12339869961624195anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with escaped characters, member 1 is valid
Original schema
{
"enum": [
"foo\nbar",
"foo\rbar"
]
}
Schema after validating
{
"enum": [
"foo\nbar",
"foo\rbar"
],
"id": "3086227853132921anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with escaped characters, member 2 is valid
Original schema
{
"enum": [
"foo\nbar",
"foo\rbar"
]
}
Schema after validating
{
"enum": [
"foo\nbar",
"foo\rbar"
],
"id": "3086227853132921anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with escaped characters, another string is invalid
Original schema
{
"enum": [
"foo\nbar",
"foo\rbar"
]
}
Schema after validating
{
"enum": [
"foo\nbar",
"foo\rbar"
],
"id": "3086227853132921anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with false does not match 0, false is valid
Original schema
{
"enum": [
false
]
}
Schema after validating
{
"enum": [
false
],
"id": "10226431988712137anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with false does not match 0, integer zero is invalid
Original schema
{
"enum": [
false
]
}
Schema after validating
{
"enum": [
false
],
"id": "10226431988712137anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with false does not match 0, float zero is invalid
Original schema
{
"enum": [
false
]
}
Schema after validating
{
"enum": [
false
],
"id": "10226431988712137anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with true does not match 1, true is valid
Original schema
{
"enum": [
true
]
}
Schema after validating
{
"enum": [
true
],
"id": "17903810412329202anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with true does not match 1, integer one is invalid
Original schema
{
"enum": [
true
]
}
Schema after validating
{
"enum": [
true
],
"id": "17903810412329202anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with true does not match 1, float one is invalid
Original schema
{
"enum": [
true
]
}
Schema after validating
{
"enum": [
true
],
"id": "17903810412329202anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with 0 does not match false, false is invalid
Original schema
{
"enum": [
0
]
}
Schema after validating
{
"enum": [
0
],
"id": "7936384663106992anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with 0 does not match false, integer zero is valid
Original schema
{
"enum": [
0
]
}
Schema after validating
{
"enum": [
0
],
"id": "7936384663106992anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with 0 does not match false, float zero is valid
Original schema
{
"enum": [
0
]
}
Schema after validating
{
"enum": [
0
],
"id": "7936384663106992anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with 1 does not match true, true is invalid
Original schema
{
"enum": [
1
]
}
Schema after validating
{
"enum": [
1
],
"id": "6000438329694526anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with 1 does not match true, integer one is valid
Original schema
{
"enum": [
1
]
}
Schema after validating
{
"enum": [
1
],
"id": "6000438329694526anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test enum with 1 does not match true, float one is valid
Original schema
{
"enum": [
1
]
}
Schema after validating
{
"enum": [
1
],
"id": "6000438329694526anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nul characters in strings, match string with nul
Original schema
{
"enum": [
"hello\u0000there"
]
}
Schema after validating
{
"enum": [
"hello\u0000there"
],
"id": "8244903691347607anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nul characters in strings, do not match string lacking nul
Original schema
{
"enum": [
"hello\u0000there"
]
}
Schema after validating
{
"enum": [
"hello\u0000there"
],
"id": "8244903691347607anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMaximum validation, below the exclusiveMaximum is valid
Original schema
{
"exclusiveMaximum": 3
}
Schema after validating
{
"exclusiveMaximum": 3,
"id": "7992199091608931anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMaximum validation, boundary point is invalid
Original schema
{
"exclusiveMaximum": 3
}
Schema after validating
{
"exclusiveMaximum": 3,
"id": "7992199091608931anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMaximum validation, above the exclusiveMaximum is invalid
Original schema
{
"exclusiveMaximum": 3
}
Schema after validating
{
"exclusiveMaximum": 3,
"id": "7992199091608931anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMaximum validation, ignores non-numbers
Original schema
{
"exclusiveMaximum": 3
}
Schema after validating
{
"exclusiveMaximum": 3,
"id": "7992199091608931anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMinimum validation, above the exclusiveMinimum is valid
Original schema
{
"exclusiveMinimum": 1.1
}
Schema after validating
{
"exclusiveMinimum": 1.1,
"id": "2531189170040964anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMinimum validation, boundary point is invalid
Original schema
{
"exclusiveMinimum": 1.1
}
Schema after validating
{
"exclusiveMinimum": 1.1,
"id": "2531189170040964anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMinimum validation, below the exclusiveMinimum is invalid
Original schema
{
"exclusiveMinimum": 1.1
}
Schema after validating
{
"exclusiveMinimum": 1.1,
"id": "2531189170040964anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test exclusiveMinimum validation, ignores non-numbers
Original schema
{
"exclusiveMinimum": 1.1
}
Schema after validating
{
"exclusiveMinimum": 1.1,
"id": "2531189170040964anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, ignores integers
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "29506060847161564anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, ignores floats
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "29506060847161564anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, ignores objects
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "29506060847161564anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, ignores arrays
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "29506060847161564anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, ignores booleans
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "29506060847161564anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, ignores null
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "29506060847161564anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN e-mail addresses, ignores integers
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7447341335420241anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN e-mail addresses, ignores floats
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7447341335420241anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN e-mail addresses, ignores objects
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7447341335420241anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN e-mail addresses, ignores arrays
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7447341335420241anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN e-mail addresses, ignores booleans
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7447341335420241anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN e-mail addresses, ignores null
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7447341335420241anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regexes, ignores integers
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "9738049564853117anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regexes, ignores floats
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "9738049564853117anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regexes, ignores objects
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "9738049564853117anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regexes, ignores arrays
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "9738049564853117anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regexes, ignores booleans
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "9738049564853117anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regexes, ignores null
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "9738049564853117anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, ignores integers
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "24980312218865408anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, ignores floats
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "24980312218865408anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, ignores objects
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "24980312218865408anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, ignores arrays
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "24980312218865408anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, ignores booleans
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "24980312218865408anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, ignores null
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "24980312218865408anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ignores integers
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "944273497450665anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ignores floats
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "944273497450665anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ignores objects
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "944273497450665anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ignores arrays
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "944273497450665anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ignores booleans
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "944273497450665anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ignores null
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "944273497450665anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN hostnames, ignores integers
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "5275158031214535anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN hostnames, ignores floats
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "5275158031214535anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN hostnames, ignores objects
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "5275158031214535anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN hostnames, ignores arrays
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "5275158031214535anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN hostnames, ignores booleans
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "5275158031214535anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IDN hostnames, ignores null
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "5275158031214535anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of hostnames, ignores integers
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "11271803566253391anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of hostnames, ignores floats
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "11271803566253391anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of hostnames, ignores objects
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "11271803566253391anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of hostnames, ignores arrays
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "11271803566253391anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of hostnames, ignores booleans
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "11271803566253391anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of hostnames, ignores null
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "11271803566253391anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, ignores integers
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "1781620636104062anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, ignores floats
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "1781620636104062anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, ignores objects
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "1781620636104062anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, ignores arrays
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "1781620636104062anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, ignores booleans
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "1781620636104062anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, ignores null
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "1781620636104062anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, ignores integers
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "06384779565153531anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, ignores floats
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "06384779565153531anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, ignores objects
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "06384779565153531anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, ignores arrays
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "06384779565153531anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, ignores booleans
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "06384779565153531anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, ignores null
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "06384779565153531anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, ignores integers
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "26883238232130124anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, ignores floats
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "26883238232130124anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, ignores objects
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "26883238232130124anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, ignores arrays
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "26883238232130124anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, ignores booleans
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "26883238232130124anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, ignores null
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "26883238232130124anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON pointers, ignores integers
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "7409030092560243anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON pointers, ignores floats
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "7409030092560243anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON pointers, ignores objects
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "7409030092560243anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON pointers, ignores arrays
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "7409030092560243anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON pointers, ignores booleans
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "7409030092560243anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON pointers, ignores null
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "7409030092560243anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of relative JSON pointers, ignores integers
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "2601535003067621anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of relative JSON pointers, ignores floats
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "2601535003067621anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of relative JSON pointers, ignores objects
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "2601535003067621anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of relative JSON pointers, ignores arrays
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "2601535003067621anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of relative JSON pointers, ignores booleans
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "2601535003067621anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of relative JSON pointers, ignores null
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "2601535003067621anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, ignores integers
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "6857039112229553anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, ignores floats
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "6857039112229553anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, ignores objects
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "6857039112229553anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, ignores arrays
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "6857039112229553anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, ignores booleans
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "6857039112229553anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, ignores null
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "6857039112229553anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI references, ignores integers
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "7768168653386676anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI references, ignores floats
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "7768168653386676anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI references, ignores objects
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "7768168653386676anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI references, ignores arrays
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "7768168653386676anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI references, ignores booleans
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "7768168653386676anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI references, ignores null
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "7768168653386676anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, ignores integers
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "08712881761508529anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, ignores floats
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "08712881761508529anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, ignores objects
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "08712881761508529anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, ignores arrays
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "08712881761508529anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, ignores booleans
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "08712881761508529anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, ignores null
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "08712881761508529anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI references, ignores integers
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "8866120811617328anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI references, ignores floats
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "8866120811617328anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI references, ignores objects
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "8866120811617328anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI references, ignores arrays
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "8866120811617328anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI references, ignores booleans
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "8866120811617328anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI references, ignores null
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "8866120811617328anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI templates, ignores integers
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "6032696286429919anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI templates, ignores floats
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "6032696286429919anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI templates, ignores objects
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "6032696286429919anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI templates, ignores arrays
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "6032696286429919anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI templates, ignores booleans
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "6032696286429919anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI templates, ignores null
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "6032696286429919anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ignore if without then or else, valid when valid against lone if
Original schema
{
"if": {
"const": 0
}
}
Schema after validating
{
"if": {
"const": 0
},
"id": "8737734142801201anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ignore if without then or else, valid when invalid against lone if
Original schema
{
"if": {
"const": 0
}
}
Schema after validating
{
"if": {
"const": 0
},
"id": "8737734142801201anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ignore then without if, valid when valid against lone then
Original schema
{
"then": {
"const": 0
}
}
Schema after validating
{
"then": {
"const": 0
},
"id": "42385794653395026anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ignore then without if, valid when invalid against lone then
Original schema
{
"then": {
"const": 0
}
}
Schema after validating
{
"then": {
"const": 0
},
"id": "42385794653395026anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ignore else without if, valid when valid against lone else
Original schema
{
"else": {
"const": 0
}
}
Schema after validating
{
"else": {
"const": 0
},
"id": "8703185287409607anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ignore else without if, valid when invalid against lone else
Original schema
{
"else": {
"const": 0
}
}
Schema after validating
{
"else": {
"const": 0
},
"id": "8703185287409607anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if and then without else, valid through then
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"id": "37333552044731766anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if and then without else, invalid through then
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"id": "37333552044731766anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if and then without else, valid when if test fails
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"id": "37333552044731766anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if and else without then, valid when if test passes
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"else": {
"multipleOf": 2
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"else": {
"multipleOf": 2
},
"id": "03434592931716152anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if and else without then, valid through else
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"else": {
"multipleOf": 2
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"else": {
"multipleOf": 2
},
"id": "03434592931716152anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if and else without then, invalid through else
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"else": {
"multipleOf": 2
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"else": {
"multipleOf": 2
},
"id": "03434592931716152anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validate against correct branch, then vs else, valid through then
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
},
"id": "8375446205927166anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validate against correct branch, then vs else, invalid through then
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
},
"id": "8375446205927166anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validate against correct branch, then vs else, valid through else
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
},
"id": "8375446205927166anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validate against correct branch, then vs else, invalid through else
Original schema
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
}
}
Schema after validating
{
"if": {
"exclusiveMaximum": 0
},
"then": {
"minimum": -10
},
"else": {
"multipleOf": 2
},
"id": "8375446205927166anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test non-interference across combined schemas, valid, but would have been invalid through then
Original schema
{
"allOf": [
{
"if": {
"exclusiveMaximum": 0
}
},
{
"then": {
"minimum": -10
}
},
{
"else": {
"multipleOf": 2
}
}
]
}
Schema after validating
{
"allOf": [
{
"if": {
"exclusiveMaximum": 0
}
},
{
"then": {
"minimum": -10
}
},
{
"else": {
"multipleOf": 2
}
}
],
"id": "003744586528674043anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test non-interference across combined schemas, valid, but would have been invalid through else
Original schema
{
"allOf": [
{
"if": {
"exclusiveMaximum": 0
}
},
{
"then": {
"minimum": -10
}
},
{
"else": {
"multipleOf": 2
}
}
]
}
Schema after validating
{
"allOf": [
{
"if": {
"exclusiveMaximum": 0
}
},
{
"then": {
"minimum": -10
}
},
{
"else": {
"multipleOf": 2
}
}
],
"id": "003744586528674043anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if with boolean schema true, boolean schema true in if always chooses the then path (valid)
Original schema
{
"if": true,
"then": {
"const": "then"
},
"else": {
"const": "else"
}
}
Schema after validating
{
"if": true,
"then": {
"const": "then"
},
"else": {
"const": "else"
},
"id": "6269993140001098anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if with boolean schema true, boolean schema true in if always chooses the then path (invalid)
Original schema
{
"if": true,
"then": {
"const": "then"
},
"else": {
"const": "else"
}
}
Schema after validating
{
"if": true,
"then": {
"const": "then"
},
"else": {
"const": "else"
},
"id": "6269993140001098anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if with boolean schema false, boolean schema false in if always chooses the else path (invalid)
Original schema
{
"if": false,
"then": {
"const": "then"
},
"else": {
"const": "else"
}
}
Schema after validating
{
"if": false,
"then": {
"const": "then"
},
"else": {
"const": "else"
},
"id": "9401535172289064anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if with boolean schema false, boolean schema false in if always chooses the else path (valid)
Original schema
{
"if": false,
"then": {
"const": "then"
},
"else": {
"const": "else"
}
}
Schema after validating
{
"if": false,
"then": {
"const": "then"
},
"else": {
"const": "else"
},
"id": "9401535172289064anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if appears at the end when serialized (keyword processing sequence), yes redirects to then and passes
Original schema
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
}
}
Schema after validating
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
},
"id": "6831610197212654anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if appears at the end when serialized (keyword processing sequence), other redirects to else and passes
Original schema
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
}
}
Schema after validating
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
},
"id": "6831610197212654anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if appears at the end when serialized (keyword processing sequence), no redirects to then and fails
Original schema
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
}
}
Schema after validating
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
},
"id": "6831610197212654anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test if appears at the end when serialized (keyword processing sequence), invalid redirects to else and fails
Original schema
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
}
}
Schema after validating
{
"then": {
"const": "yes"
},
"else": {
"const": "other"
},
"if": {
"maxLength": 4
},
"id": "6831610197212654anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test evaluating the same schema location against the same data location twice is not a sign of an infinite loop, passing case
Original schema
{
"definitions": {
"int": {
"type": "integer"
}
},
"allOf": [
{
"properties": {
"foo": {
"$ref": "#/definitions/int"
}
}
},
{
"additionalProperties": {
"$ref": "#/definitions/int"
}
}
]
}
Schema after validating
{
"definitions": {
"int": {
"type": "integer",
"id": "38062992656816275anonymous#/definitions/int"
}
},
"allOf": [
{
"properties": {
"foo": {
"$ref": "38062992656816275anonymous#/definitions/int"
}
}
},
{
"additionalProperties": {
"$ref": "38062992656816275anonymous#/definitions/int"
}
}
],
"id": "38062992656816275anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test evaluating the same schema location against the same data location twice is not a sign of an infinite loop, failing case
Original schema
{
"definitions": {
"int": {
"type": "integer"
}
},
"allOf": [
{
"properties": {
"foo": {
"$ref": "#/definitions/int"
}
}
},
{
"additionalProperties": {
"$ref": "#/definitions/int"
}
}
]
}
Schema after validating
{
"definitions": {
"int": {
"type": "integer",
"id": "38062992656816275anonymous#/definitions/int"
}
},
"allOf": [
{
"properties": {
"foo": {
"$ref": "38062992656816275anonymous#/definitions/int"
}
}
},
{
"additionalProperties": {
"$ref": "38062992656816275anonymous#/definitions/int"
}
}
],
"id": "38062992656816275anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test a schema given for items, valid items
Original schema
{
"items": {
"type": "integer"
}
}
Schema after validating
{
"items": {
"type": "integer"
},
"id": "12491319347735397anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test a schema given for items, wrong type of items
Original schema
{
"items": {
"type": "integer"
}
}
Schema after validating
{
"items": {
"type": "integer"
},
"id": "12491319347735397anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test a schema given for items, ignores non-arrays
Original schema
{
"items": {
"type": "integer"
}
}
Schema after validating
{
"items": {
"type": "integer"
},
"id": "12491319347735397anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test a schema given for items, JavaScript pseudo-array is valid
Original schema
{
"items": {
"type": "integer"
}
}
Schema after validating
{
"items": {
"type": "integer"
},
"id": "12491319347735397anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test an array of schemas for items, correct types
Original schema
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
],
"id": "6517873817666608anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test an array of schemas for items, wrong types
Original schema
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
],
"id": "6517873817666608anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test an array of schemas for items, incomplete array of items
Original schema
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
],
"id": "6517873817666608anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test an array of schemas for items, array with additional items
Original schema
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
],
"id": "6517873817666608anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test an array of schemas for items, empty array
Original schema
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
],
"id": "6517873817666608anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test an array of schemas for items, JavaScript pseudo-array is valid
Original schema
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer"
},
{
"type": "string"
}
],
"id": "6517873817666608anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items with boolean schema (true), any array is valid
Original schema
{
"items": true
}
Schema after validating
{
"items": true,
"id": "2222358592660616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items with boolean schema (true), empty array is valid
Original schema
{
"items": true
}
Schema after validating
{
"items": true,
"id": "2222358592660616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items with boolean schema (false), any non-empty array is invalid
Original schema
{
"items": false
}
Schema after validating
{
"items": false,
"id": "39542329079586347anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items with boolean schema (false), empty array is valid
Original schema
{
"items": false
}
Schema after validating
{
"items": false,
"id": "39542329079586347anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items and subitems, valid items
Original schema
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/sub-item"
},
{
"$ref": "#/definitions/sub-item"
}
]
},
"sub-item": {
"type": "object",
"required": [
"foo"
]
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
}
]
}
Schema after validating
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
},
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
}
],
"id": "06535195683395423anonymous#/definitions/item"
},
"sub-item": {
"type": "object",
"required": [
"foo"
],
"id": "06535195683395423anonymous#/definitions/sub-item"
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
}
],
"id": "06535195683395423anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items and subitems, too many items
Original schema
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/sub-item"
},
{
"$ref": "#/definitions/sub-item"
}
]
},
"sub-item": {
"type": "object",
"required": [
"foo"
]
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
}
]
}
Schema after validating
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
},
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
}
],
"id": "06535195683395423anonymous#/definitions/item"
},
"sub-item": {
"type": "object",
"required": [
"foo"
],
"id": "06535195683395423anonymous#/definitions/sub-item"
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
}
],
"id": "06535195683395423anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items and subitems, too many sub-items
Original schema
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/sub-item"
},
{
"$ref": "#/definitions/sub-item"
}
]
},
"sub-item": {
"type": "object",
"required": [
"foo"
]
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
}
]
}
Schema after validating
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
},
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
}
],
"id": "06535195683395423anonymous#/definitions/item"
},
"sub-item": {
"type": "object",
"required": [
"foo"
],
"id": "06535195683395423anonymous#/definitions/sub-item"
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
}
],
"id": "06535195683395423anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items and subitems, wrong item
Original schema
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/sub-item"
},
{
"$ref": "#/definitions/sub-item"
}
]
},
"sub-item": {
"type": "object",
"required": [
"foo"
]
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
}
]
}
Schema after validating
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
},
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
}
],
"id": "06535195683395423anonymous#/definitions/item"
},
"sub-item": {
"type": "object",
"required": [
"foo"
],
"id": "06535195683395423anonymous#/definitions/sub-item"
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
}
],
"id": "06535195683395423anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items and subitems, wrong sub-item
Original schema
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/sub-item"
},
{
"$ref": "#/definitions/sub-item"
}
]
},
"sub-item": {
"type": "object",
"required": [
"foo"
]
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
}
]
}
Schema after validating
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
},
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
}
],
"id": "06535195683395423anonymous#/definitions/item"
},
"sub-item": {
"type": "object",
"required": [
"foo"
],
"id": "06535195683395423anonymous#/definitions/sub-item"
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
}
],
"id": "06535195683395423anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test items and subitems, fewer items is valid
Original schema
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/sub-item"
},
{
"$ref": "#/definitions/sub-item"
}
]
},
"sub-item": {
"type": "object",
"required": [
"foo"
]
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
},
{
"$ref": "#/definitions/item"
}
]
}
Schema after validating
{
"definitions": {
"item": {
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
},
{
"$ref": "06535195683395423anonymous#/definitions/sub-item"
}
],
"id": "06535195683395423anonymous#/definitions/item"
},
"sub-item": {
"type": "object",
"required": [
"foo"
],
"id": "06535195683395423anonymous#/definitions/sub-item"
}
},
"type": "array",
"additionalItems": false,
"items": [
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
},
{
"$ref": "06535195683395423anonymous#/definitions/item"
}
],
"id": "06535195683395423anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested items, valid nested array
Original schema
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
}
}
Schema after validating
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
},
"id": "16939279288170095anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested items, nested array with invalid type
Original schema
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
}
}
Schema after validating
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
},
"id": "16939279288170095anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested items, not deep enough
Original schema
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
}
}
Schema after validating
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
},
"id": "16939279288170095anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxItems validation, shorter is valid
Original schema
{
"maxItems": 2
}
Schema after validating
{
"maxItems": 2,
"id": "1960986898415018anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxItems validation, exact length is valid
Original schema
{
"maxItems": 2
}
Schema after validating
{
"maxItems": 2,
"id": "1960986898415018anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxItems validation, too long is invalid
Original schema
{
"maxItems": 2
}
Schema after validating
{
"maxItems": 2,
"id": "1960986898415018anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxItems validation, ignores non-arrays
Original schema
{
"maxItems": 2
}
Schema after validating
{
"maxItems": 2,
"id": "1960986898415018anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxLength validation, shorter is valid
Original schema
{
"maxLength": 2
}
Schema after validating
{
"maxLength": 2,
"id": "38801592319915645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxLength validation, exact length is valid
Original schema
{
"maxLength": 2
}
Schema after validating
{
"maxLength": 2,
"id": "38801592319915645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxLength validation, too long is invalid
Original schema
{
"maxLength": 2
}
Schema after validating
{
"maxLength": 2,
"id": "38801592319915645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxLength validation, ignores non-strings
Original schema
{
"maxLength": 2
}
Schema after validating
{
"maxLength": 2,
"id": "38801592319915645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxLength validation, two supplementary Unicode code points is long enough
Original schema
{
"maxLength": 2
}
Schema after validating
{
"maxLength": 2,
"id": "38801592319915645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties validation, shorter is valid
Original schema
{
"maxProperties": 2
}
Schema after validating
{
"maxProperties": 2,
"id": "9784876904896513anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties validation, exact length is valid
Original schema
{
"maxProperties": 2
}
Schema after validating
{
"maxProperties": 2,
"id": "9784876904896513anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties validation, too long is invalid
Original schema
{
"maxProperties": 2
}
Schema after validating
{
"maxProperties": 2,
"id": "9784876904896513anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties validation, ignores arrays
Original schema
{
"maxProperties": 2
}
Schema after validating
{
"maxProperties": 2,
"id": "9784876904896513anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties validation, ignores strings
Original schema
{
"maxProperties": 2
}
Schema after validating
{
"maxProperties": 2,
"id": "9784876904896513anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties validation, ignores other non-objects
Original schema
{
"maxProperties": 2
}
Schema after validating
{
"maxProperties": 2,
"id": "9784876904896513anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties = 0 means the object is empty, no properties is valid
Original schema
{
"maxProperties": 0
}
Schema after validating
{
"maxProperties": 0,
"id": "6032599225952355anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maxProperties = 0 means the object is empty, one property is invalid
Original schema
{
"maxProperties": 0
}
Schema after validating
{
"maxProperties": 0,
"id": "6032599225952355anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation, below the maximum is valid
Original schema
{
"maximum": 3
}
Schema after validating
{
"maximum": 3,
"id": "8906174320411855anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation, boundary point is valid
Original schema
{
"maximum": 3
}
Schema after validating
{
"maximum": 3,
"id": "8906174320411855anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation, above the maximum is invalid
Original schema
{
"maximum": 3
}
Schema after validating
{
"maximum": 3,
"id": "8906174320411855anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation, ignores non-numbers
Original schema
{
"maximum": 3
}
Schema after validating
{
"maximum": 3,
"id": "8906174320411855anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation with unsigned integer, below the maximum is invalid
Original schema
{
"maximum": 300
}
Schema after validating
{
"maximum": 300,
"id": "09038072018975041anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation with unsigned integer, boundary point integer is valid
Original schema
{
"maximum": 300
}
Schema after validating
{
"maximum": 300,
"id": "09038072018975041anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation with unsigned integer, boundary point float is valid
Original schema
{
"maximum": 300
}
Schema after validating
{
"maximum": 300,
"id": "09038072018975041anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test maximum validation with unsigned integer, above the maximum is invalid
Original schema
{
"maximum": 300
}
Schema after validating
{
"maximum": 300,
"id": "09038072018975041anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minItems validation, longer is valid
Original schema
{
"minItems": 1
}
Schema after validating
{
"minItems": 1,
"id": "6624578671946681anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minItems validation, exact length is valid
Original schema
{
"minItems": 1
}
Schema after validating
{
"minItems": 1,
"id": "6624578671946681anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minItems validation, too short is invalid
Original schema
{
"minItems": 1
}
Schema after validating
{
"minItems": 1,
"id": "6624578671946681anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minItems validation, ignores non-arrays
Original schema
{
"minItems": 1
}
Schema after validating
{
"minItems": 1,
"id": "6624578671946681anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minLength validation, longer is valid
Original schema
{
"minLength": 2
}
Schema after validating
{
"minLength": 2,
"id": "6423688059584345anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minLength validation, exact length is valid
Original schema
{
"minLength": 2
}
Schema after validating
{
"minLength": 2,
"id": "6423688059584345anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minLength validation, too short is invalid
Original schema
{
"minLength": 2
}
Schema after validating
{
"minLength": 2,
"id": "6423688059584345anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minLength validation, ignores non-strings
Original schema
{
"minLength": 2
}
Schema after validating
{
"minLength": 2,
"id": "6423688059584345anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minLength validation, one supplementary Unicode code point is not long enough
Original schema
{
"minLength": 2
}
Schema after validating
{
"minLength": 2,
"id": "6423688059584345anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minProperties validation, longer is valid
Original schema
{
"minProperties": 1
}
Schema after validating
{
"minProperties": 1,
"id": "22397854397820693anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minProperties validation, exact length is valid
Original schema
{
"minProperties": 1
}
Schema after validating
{
"minProperties": 1,
"id": "22397854397820693anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minProperties validation, too short is invalid
Original schema
{
"minProperties": 1
}
Schema after validating
{
"minProperties": 1,
"id": "22397854397820693anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minProperties validation, ignores arrays
Original schema
{
"minProperties": 1
}
Schema after validating
{
"minProperties": 1,
"id": "22397854397820693anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minProperties validation, ignores strings
Original schema
{
"minProperties": 1
}
Schema after validating
{
"minProperties": 1,
"id": "22397854397820693anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minProperties validation, ignores other non-objects
Original schema
{
"minProperties": 1
}
Schema after validating
{
"minProperties": 1,
"id": "22397854397820693anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation, above the minimum is valid
Original schema
{
"minimum": 1.1
}
Schema after validating
{
"minimum": 1.1,
"id": "9105536286927258anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation, boundary point is valid
Original schema
{
"minimum": 1.1
}
Schema after validating
{
"minimum": 1.1,
"id": "9105536286927258anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation, below the minimum is invalid
Original schema
{
"minimum": 1.1
}
Schema after validating
{
"minimum": 1.1,
"id": "9105536286927258anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation, ignores non-numbers
Original schema
{
"minimum": 1.1
}
Schema after validating
{
"minimum": 1.1,
"id": "9105536286927258anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation with signed integer, negative above the minimum is valid
Original schema
{
"minimum": -2
}
Schema after validating
{
"minimum": -2,
"id": "6165690783449378anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation with signed integer, positive above the minimum is valid
Original schema
{
"minimum": -2
}
Schema after validating
{
"minimum": -2,
"id": "6165690783449378anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation with signed integer, boundary point is valid
Original schema
{
"minimum": -2
}
Schema after validating
{
"minimum": -2,
"id": "6165690783449378anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation with signed integer, boundary point with float is valid
Original schema
{
"minimum": -2
}
Schema after validating
{
"minimum": -2,
"id": "6165690783449378anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation with signed integer, float below the minimum is invalid
Original schema
{
"minimum": -2
}
Schema after validating
{
"minimum": -2,
"id": "6165690783449378anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation with signed integer, int below the minimum is invalid
Original schema
{
"minimum": -2
}
Schema after validating
{
"minimum": -2,
"id": "6165690783449378anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test minimum validation with signed integer, ignores non-numbers
Original schema
{
"minimum": -2
}
Schema after validating
{
"minimum": -2,
"id": "6165690783449378anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by int, int by int
Original schema
{
"multipleOf": 2
}
Schema after validating
{
"multipleOf": 2,
"id": "6250380076511817anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by int, int by int fail
Original schema
{
"multipleOf": 2
}
Schema after validating
{
"multipleOf": 2,
"id": "6250380076511817anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by int, ignores non-numbers
Original schema
{
"multipleOf": 2
}
Schema after validating
{
"multipleOf": 2,
"id": "6250380076511817anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by number, zero is multiple of anything
Original schema
{
"multipleOf": 1.5
}
Schema after validating
{
"multipleOf": 1.5,
"id": "8333730588255159anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by number, 4.5 is multiple of 1.5
Original schema
{
"multipleOf": 1.5
}
Schema after validating
{
"multipleOf": 1.5,
"id": "8333730588255159anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by number, 35 is not multiple of 1.5
Original schema
{
"multipleOf": 1.5
}
Schema after validating
{
"multipleOf": 1.5,
"id": "8333730588255159anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by small number, 0.0075 is multiple of 0.0001
Original schema
{
"multipleOf": 0.0001
}
Schema after validating
{
"multipleOf": 0.0001,
"id": "7719066966347263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test by small number, 0.00751 is not multiple of 0.0001
Original schema
{
"multipleOf": 0.0001
}
Schema after validating
{
"multipleOf": 0.0001,
"id": "7719066966347263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test invalid instance should not raise error when float division = inf, always invalid, but naive implementations may raise an overflow error
Original schema
{
"type": "integer",
"multipleOf": 0.123456789
}
Schema after validating
{
"type": "integer",
"multipleOf": 0.123456789,
"id": "6157869759053793anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not, allowed
Original schema
{
"not": {
"type": "integer"
}
}
Schema after validating
{
"not": {
"type": "integer"
},
"id": "29077292341331695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not, disallowed
Original schema
{
"not": {
"type": "integer"
}
}
Schema after validating
{
"not": {
"type": "integer"
},
"id": "29077292341331695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not multiple types, valid
Original schema
{
"not": {
"type": [
"integer",
"boolean"
]
}
}
Schema after validating
{
"not": {
"type": [
"integer",
"boolean"
]
},
"id": "14808117702501367anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not multiple types, mismatch
Original schema
{
"not": {
"type": [
"integer",
"boolean"
]
}
}
Schema after validating
{
"not": {
"type": [
"integer",
"boolean"
]
},
"id": "14808117702501367anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not multiple types, other mismatch
Original schema
{
"not": {
"type": [
"integer",
"boolean"
]
}
}
Schema after validating
{
"not": {
"type": [
"integer",
"boolean"
]
},
"id": "14808117702501367anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not more complex schema, match
Original schema
{
"not": {
"type": "object",
"properties": {
"foo": {
"type": "string"
}
}
}
}
Schema after validating
{
"not": {
"type": "object",
"properties": {
"foo": {
"type": "string"
}
}
},
"id": "16774848355472138anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not more complex schema, other match
Original schema
{
"not": {
"type": "object",
"properties": {
"foo": {
"type": "string"
}
}
}
}
Schema after validating
{
"not": {
"type": "object",
"properties": {
"foo": {
"type": "string"
}
}
},
"id": "16774848355472138anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not more complex schema, mismatch
Original schema
{
"not": {
"type": "object",
"properties": {
"foo": {
"type": "string"
}
}
}
}
Schema after validating
{
"not": {
"type": "object",
"properties": {
"foo": {
"type": "string"
}
}
},
"id": "16774848355472138anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test forbidden property, property present
Original schema
{
"properties": {
"foo": {
"not": {}
}
}
}
Schema after validating
{
"properties": {
"foo": {
"not": {}
}
},
"id": "7067604940229131anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test forbidden property, property absent
Original schema
{
"properties": {
"foo": {
"not": {}
}
}
}
Schema after validating
{
"properties": {
"foo": {
"not": {}
}
},
"id": "7067604940229131anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not with boolean schema true, any value is invalid
Original schema
{
"not": true
}
Schema after validating
{
"not": true,
"id": "5926060721587219anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test not with boolean schema false, any value is valid
Original schema
{
"not": false
}
Schema after validating
{
"not": false,
"id": "8855309197269847anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf, first oneOf valid
Original schema
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "23842922228260277anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf, second oneOf valid
Original schema
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "23842922228260277anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf, both oneOf valid
Original schema
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "23842922228260277anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf, neither oneOf valid
Original schema
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
]
}
Schema after validating
{
"oneOf": [
{
"type": "integer"
},
{
"minimum": 2
}
],
"id": "23842922228260277anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with base schema, mismatch base schema
Original schema
{
"type": "string",
"oneOf": [
{
"minLength": 2
},
{
"maxLength": 4
}
]
}
Schema after validating
{
"type": "string",
"oneOf": [
{
"minLength": 2
},
{
"maxLength": 4
}
],
"id": "8217718665916809anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with base schema, one oneOf valid
Original schema
{
"type": "string",
"oneOf": [
{
"minLength": 2
},
{
"maxLength": 4
}
]
}
Schema after validating
{
"type": "string",
"oneOf": [
{
"minLength": 2
},
{
"maxLength": 4
}
],
"id": "8217718665916809anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with base schema, both oneOf valid
Original schema
{
"type": "string",
"oneOf": [
{
"minLength": 2
},
{
"maxLength": 4
}
]
}
Schema after validating
{
"type": "string",
"oneOf": [
{
"minLength": 2
},
{
"maxLength": 4
}
],
"id": "8217718665916809anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with boolean schemas, all false, any value is invalid
Original schema
{
"oneOf": [
false,
false,
false
]
}
Schema after validating
{
"oneOf": [
false,
false,
false
],
"id": "737688239879629anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf complex types, first oneOf valid (complex)
Original schema
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "7795794201934172anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf complex types, second oneOf valid (complex)
Original schema
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "7795794201934172anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf complex types, both oneOf valid (complex)
Original schema
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "7795794201934172anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf complex types, neither oneOf valid (complex)
Original schema
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
]
}
Schema after validating
{
"oneOf": [
{
"properties": {
"bar": {
"type": "integer"
}
},
"required": [
"bar"
]
},
{
"properties": {
"foo": {
"type": "string"
}
},
"required": [
"foo"
]
}
],
"id": "7795794201934172anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with empty schema, one valid - valid
Original schema
{
"oneOf": [
{
"type": "number"
},
{}
]
}
Schema after validating
{
"oneOf": [
{
"type": "number"
},
{}
],
"id": "5957624780866762anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with empty schema, both valid - invalid
Original schema
{
"oneOf": [
{
"type": "number"
},
{}
]
}
Schema after validating
{
"oneOf": [
{
"type": "number"
},
{}
],
"id": "5957624780866762anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with required, both invalid - invalid
Original schema
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
]
}
Schema after validating
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
],
"id": "34381902547794274anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with required, first valid - valid
Original schema
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
]
}
Schema after validating
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
],
"id": "34381902547794274anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with required, second valid - valid
Original schema
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
]
}
Schema after validating
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
],
"id": "34381902547794274anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test oneOf with required, both valid - invalid
Original schema
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
]
}
Schema after validating
{
"type": "object",
"oneOf": [
{
"required": [
"foo",
"bar"
]
},
{
"required": [
"foo",
"baz"
]
}
],
"id": "34381902547794274anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested oneOf, to check validation semantics, null is valid
Original schema
{
"oneOf": [
{
"oneOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"oneOf": [
{
"oneOf": [
{
"type": "null"
}
]
}
],
"id": "41078003981972966anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested oneOf, to check validation semantics, anything non-null is invalid
Original schema
{
"oneOf": [
{
"oneOf": [
{
"type": "null"
}
]
}
]
}
Schema after validating
{
"oneOf": [
{
"oneOf": [
{
"type": "null"
}
]
}
],
"id": "41078003981972966anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer, a bignum is an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "29078217224042335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number, a bignum is a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "41219893603850033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer, a negative bignum is an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "2334396951915214anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number, a negative bignum is a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "28438772007008395anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string, a bignum is not a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "34238566675362736anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer comparison, comparison works for high numbers
Original schema
{
"maximum": 18446744073709552000
}
Schema after validating
{
"maximum": 18446744073709552000,
"id": "1316951806038391anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test float comparison with high precision, comparison works for high numbers
Original schema
{
"exclusiveMaximum": 9.727837981879871e+26
}
Schema after validating
{
"exclusiveMaximum": 9.727837981879871e+26,
"id": "1309467961942914anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer comparison, comparison works for very negative numbers
Original schema
{
"minimum": -18446744073709552000
}
Schema after validating
{
"minimum": -18446744073709552000,
"id": "7481321989160656anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test float comparison with high precision on negative numbers, comparison works for very negative numbers
Original schema
{
"exclusiveMinimum": -9.727837981879871e+26
}
Schema after validating
{
"exclusiveMinimum": -9.727837981879871e+26,
"id": "4655240667870484anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of string-encoded content based on media type, a valid JSON document
Original schema
{
"contentMediaType": "application/json"
}
Schema after validating
{
"contentMediaType": "application/json",
"id": "15163528103033186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of string-encoded content based on media type, an invalid JSON document
Original schema
{
"contentMediaType": "application/json"
}
Schema after validating
{
"contentMediaType": "application/json",
"id": "15163528103033186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of string-encoded content based on media type, ignores non-strings
Original schema
{
"contentMediaType": "application/json"
}
Schema after validating
{
"contentMediaType": "application/json",
"id": "15163528103033186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of binary string-encoding, a valid base64 string
Original schema
{
"contentEncoding": "base64"
}
Schema after validating
{
"contentEncoding": "base64",
"id": "04316906395260589anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of binary string-encoding, an invalid base64 string (% is not a valid character)
Original schema
{
"contentEncoding": "base64"
}
Schema after validating
{
"contentEncoding": "base64",
"id": "04316906395260589anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of binary string-encoding, ignores non-strings
Original schema
{
"contentEncoding": "base64"
}
Schema after validating
{
"contentEncoding": "base64",
"id": "04316906395260589anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of binary-encoded media type documents, a valid base64-encoded JSON document
Original schema
{
"contentMediaType": "application/json",
"contentEncoding": "base64"
}
Schema after validating
{
"contentMediaType": "application/json",
"contentEncoding": "base64",
"id": "9297843891454107anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of binary-encoded media type documents, a validly-encoded invalid JSON document
Original schema
{
"contentMediaType": "application/json",
"contentEncoding": "base64"
}
Schema after validating
{
"contentMediaType": "application/json",
"contentEncoding": "base64",
"id": "9297843891454107anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of binary-encoded media type documents, an invalid base64 string that is valid JSON
Original schema
{
"contentMediaType": "application/json",
"contentEncoding": "base64"
}
Schema after validating
{
"contentMediaType": "application/json",
"contentEncoding": "base64",
"id": "9297843891454107anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of binary-encoded media type documents, ignores non-strings
Original schema
{
"contentMediaType": "application/json",
"contentEncoding": "base64"
}
Schema after validating
{
"contentMediaType": "application/json",
"contentEncoding": "base64",
"id": "9297843891454107anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex $ does not match trailing newline, matches in Python, but should not in jsonschema
Original schema
{
"type": "string",
"pattern": "^abc$"
}
Schema after validating
{
"type": "string",
"pattern": "^abc$",
"id": "08693420295158494anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex $ does not match trailing newline, should match
Original schema
{
"type": "string",
"pattern": "^abc$"
}
Schema after validating
{
"type": "string",
"pattern": "^abc$",
"id": "08693420295158494anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex converts \t to horizontal tab, does not match
Original schema
{
"type": "string",
"pattern": "^\\t$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\t$",
"id": "0652568232978834anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex converts \t to horizontal tab, matches
Original schema
{
"type": "string",
"pattern": "^\\t$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\t$",
"id": "0652568232978834anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex escapes control codes with \c and upper letter, does not match
Original schema
{
"type": "string",
"pattern": "^\\cC$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\cC$",
"id": "8339650423936498anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex escapes control codes with \c and upper letter, matches
Original schema
{
"type": "string",
"pattern": "^\\cC$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\cC$",
"id": "8339650423936498anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex escapes control codes with \c and lower letter, does not match
Original schema
{
"type": "string",
"pattern": "^\\cc$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\cc$",
"id": "25836664807527865anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 regex escapes control codes with \c and lower letter, matches
Original schema
{
"type": "string",
"pattern": "^\\cc$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\cc$",
"id": "25836664807527865anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \d matches ascii digits only, ASCII zero matches
Original schema
{
"type": "string",
"pattern": "^\\d$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\d$",
"id": "7862980730033036anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \d matches ascii digits only, NKO DIGIT ZERO does not match (unlike e.g. Python)
Original schema
{
"type": "string",
"pattern": "^\\d$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\d$",
"id": "7862980730033036anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \d matches ascii digits only, NKO DIGIT ZERO (as \u escape) does not match
Original schema
{
"type": "string",
"pattern": "^\\d$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\d$",
"id": "7862980730033036anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \D matches everything but ascii digits, ASCII zero does not match
Original schema
{
"type": "string",
"pattern": "^\\D$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\D$",
"id": "33216688703706176anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \D matches everything but ascii digits, NKO DIGIT ZERO matches (unlike e.g. Python)
Original schema
{
"type": "string",
"pattern": "^\\D$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\D$",
"id": "33216688703706176anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \D matches everything but ascii digits, NKO DIGIT ZERO (as \u escape) matches
Original schema
{
"type": "string",
"pattern": "^\\D$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\D$",
"id": "33216688703706176anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \w matches ascii letters only, ASCII 'a' matches
Original schema
{
"type": "string",
"pattern": "^\\w$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\w$",
"id": "04186458464728626anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \w matches ascii letters only, latin-1 e-acute does not match (unlike e.g. Python)
Original schema
{
"type": "string",
"pattern": "^\\w$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\w$",
"id": "04186458464728626anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \W matches everything but ascii letters, ASCII 'a' does not match
Original schema
{
"type": "string",
"pattern": "^\\W$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\W$",
"id": "35435760255542004anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \W matches everything but ascii letters, latin-1 e-acute matches (unlike e.g. Python)
Original schema
{
"type": "string",
"pattern": "^\\W$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\W$",
"id": "35435760255542004anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, ASCII space matches
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, Character tabulation matches
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, Line tabulation matches
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, Form feed matches
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, latin-1 non-breaking-space matches
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, zero-width whitespace matches
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, line feed matches (line terminator)
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, paragraph separator matches (line terminator)
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, EM SPACE matches (Space_Separator)
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, Non-whitespace control does not match
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \s matches whitespace, Non-whitespace does not match
Original schema
{
"type": "string",
"pattern": "^\\s$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\s$",
"id": "7155661467403645anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, ASCII space does not match
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, Character tabulation does not match
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, Line tabulation does not match
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, Form feed does not match
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, latin-1 non-breaking-space does not match
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, zero-width whitespace does not match
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, line feed does not match (line terminator)
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, paragraph separator does not match (line terminator)
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, EM SPACE does not match (Space_Separator)
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, Non-whitespace control matches
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ECMA 262 \S matches everything but whitespace, Non-whitespace matches
Original schema
{
"type": "string",
"pattern": "^\\S$"
}
Schema after validating
{
"type": "string",
"pattern": "^\\S$",
"id": "4973849741737695anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test all integers are multiples of 0.5, if overflow is handled, valid if optional overflow handling is implemented
Original schema
{
"type": "integer",
"multipleOf": 0.5
}
Schema after validating
{
"type": "integer",
"multipleOf": 0.5,
"id": "10084436166519173anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, a valid date-time string
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, a valid date-time string without second fraction
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, a valid date-time string with plus offset
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, a valid date-time string with minus offset
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, a invalid day in date-time string
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, an invalid offset in date-time string
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, an invalid date-time string
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, case-insensitive T and Z
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, only RFC3339 not all of ISO 8601 are valid
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, invalid non-padded month dates
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date-time strings, invalid non-padded day dates
Original schema
{
"format": "date-time"
}
Schema after validating
{
"format": "date-time",
"id": "6092413651995103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, a valid date string
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "8212329522280142anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, an invalid date-time string
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "8212329522280142anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, only RFC3339 not all of ISO 8601 are valid
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "8212329522280142anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, invalidates non-padded month dates
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "8212329522280142anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of date strings, invalidates non-padded day dates
Original schema
{
"format": "date"
}
Schema after validating
{
"format": "date",
"id": "8212329522280142anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, a valid e-mail address
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, an invalid e-mail address
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, tilde in local part is valid
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, tilde before local part is valid
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, tilde after local part is valid
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, dot before local part is not valid
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, dot after local part is not valid
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, two separated dots inside local part are valid
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of e-mail addresses, two subsequent dots inside local part are not valid
Original schema
{
"format": "email"
}
Schema after validating
{
"format": "email",
"id": "13732319088893052anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, a valid host name
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, a valid punycoded IDN hostname
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, a host name starting with an illegal character
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, a host name containing illegal characters
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, a host name with a component too long
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, starts with hyphen
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, ends with hyphen
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, starts with underscore
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, ends with underscore
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, contains underscore
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, maximum label length
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of host names, exceeds maximum label length
Original schema
{
"format": "hostname"
}
Schema after validating
{
"format": "hostname",
"id": "0738363135557818anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of an internationalized e-mail addresses, a valid idn e-mail (example@example.test in Hangul)
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7805293752202125anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of an internationalized e-mail addresses, an invalid idn e-mail address
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7805293752202125anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of an internationalized e-mail addresses, a valid e-mail address
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7805293752202125anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of an internationalized e-mail addresses, an invalid e-mail address
Original schema
{
"format": "idn-email"
}
Schema after validating
{
"format": "idn-email",
"id": "7805293752202125anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, a valid host name (example.test in Hangul)
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, illegal first char U+302E Hangul single dot tone mark
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, contains illegal char U+302E Hangul single dot tone mark
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, a host name with a component too long
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, invalid label, correct Punycode
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, valid Chinese Punycode
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, invalid Punycode
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, U-label contains "--" in the 3rd and 4th position
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, U-label starts with a dash
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, U-label ends with a dash
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, U-label starts and ends with a dash
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Begins with a Spacing Combining Mark
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Begins with a Nonspacing Mark
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Begins with an Enclosing Mark
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Exceptions that are PVALID, left-to-right chars
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Exceptions that are PVALID, right-to-left chars
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Exceptions that are DISALLOWED, right-to-left chars
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Exceptions that are DISALLOWED, left-to-right chars
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, MIDDLE DOT with no preceding 'l'
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, MIDDLE DOT with nothing preceding
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, MIDDLE DOT with no following 'l'
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, MIDDLE DOT with nothing following
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, MIDDLE DOT with surrounding 'l's
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Greek KERAIA not followed by Greek
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Greek KERAIA not followed by anything
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Greek KERAIA followed by Greek
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Hebrew GERESH not preceded by Hebrew
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Hebrew GERESH not preceded by anything
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Hebrew GERESH preceded by Hebrew
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Hebrew GERSHAYIM not preceded by Hebrew
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Hebrew GERSHAYIM not preceded by anything
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Hebrew GERSHAYIM preceded by Hebrew
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, KATAKANA MIDDLE DOT with no Hiragana, Katakana, or Han
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, KATAKANA MIDDLE DOT with no other characters
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, KATAKANA MIDDLE DOT with Hiragana
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, KATAKANA MIDDLE DOT with Katakana
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, KATAKANA MIDDLE DOT with Han
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Arabic-Indic digits mixed with Extended Arabic-Indic digits
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Arabic-Indic digits not mixed with Extended Arabic-Indic digits
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, Extended Arabic-Indic digits not mixed with Arabic-Indic digits
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, ZERO WIDTH JOINER not preceded by Virama
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, ZERO WIDTH JOINER not preceded by anything
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, ZERO WIDTH JOINER preceded by Virama
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, ZERO WIDTH NON-JOINER preceded by Virama
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of internationalized host names, ZERO WIDTH NON-JOINER not preceded by Virama but matches regexp
Original schema
{
"format": "idn-hostname"
}
Schema after validating
{
"format": "idn-hostname",
"id": "4854173257227772anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, a valid IP address
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "4068931135097016anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, an IP address with too many components
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "4068931135097016anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, an IP address with out-of-range values
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "4068931135097016anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, an IP address without 4 components
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "4068931135097016anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, an IP address as an integer
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "4068931135097016anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IP addresses, an IP address as an integer (decimal)
Original schema
{
"format": "ipv4"
}
Schema after validating
{
"format": "ipv4",
"id": "4068931135097016anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, a valid IPv6 address
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, an IPv6 address with out-of-range values
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, an IPv6 address with too many components
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, an IPv6 address containing illegal characters
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, no digits is valid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, leading colons is valid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, trailing colons is valid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, missing leading octet is invalid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, missing trailing octet is invalid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, missing leading octet with omitted octets later
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, two sets of double colons is invalid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, mixed format with the ipv4 section as decimal octets
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, mixed format with double colons between the sections
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, mixed format with ipv4 section with octet out of range
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, mixed format with ipv4 section with a hex octet
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, mixed format with leading double colons (ipv4-mapped ipv6 address)
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, triple colons is invalid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, 8 octets
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, insufficient octets without double colons
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, no colons is invalid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ipv4 is not ipv6
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, ipv4 segment must have 4 octets
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, leading whitespace is invalid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, trailing whitespace is invalid
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, netmask is not a part of ipv6 address
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, zone id is not a part of ipv6 address
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, a long valid ipv6
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, a long invalid ipv6, below length limit, first
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IPv6 addresses, a long invalid ipv6, below length limit, second
Original schema
{
"format": "ipv6"
}
Schema after validating
{
"format": "ipv6",
"id": "7255735014647335anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI References, a valid IRI
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "5623929940295413anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI References, a valid protocol-relative IRI Reference
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "5623929940295413anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI References, a valid relative IRI Reference
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "5623929940295413anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI References, an invalid IRI Reference
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "5623929940295413anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI References, a valid IRI Reference
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "5623929940295413anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI References, a valid IRI fragment
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "5623929940295413anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRI References, an invalid IRI fragment
Original schema
{
"format": "iri-reference"
}
Schema after validating
{
"format": "iri-reference",
"id": "5623929940295413anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, a valid IRI with anchor tag
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, a valid IRI with anchor tag and parantheses
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, a valid IRI with URL-encoded stuff
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, a valid IRI with many special characters
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, a valid IRI based on IPv6
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, an invalid IRI based on IPv6
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, an invalid relative IRI Reference
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, an invalid IRI
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of IRIs, an invalid IRI though valid IRI reference
Original schema
{
"format": "iri"
}
Schema after validating
{
"format": "iri",
"id": "9440307356057318anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), a valid JSON-pointer
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (~ not escaped)
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer with empty segment
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer with the last empty segment
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #1
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #2
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #3
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #4
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #5
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #6
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #7
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #8
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #9
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #10
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #11
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer as stated in RFC 6901 #12
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer used adding to the last array position
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer (- used as object member name)
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer (multiple escaped characters)
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer (escaped with fraction part) #1
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), valid JSON-pointer (escaped with fraction part) #2
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (URI Fragment Identifier) #1
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (URI Fragment Identifier) #2
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (URI Fragment Identifier) #3
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (some escaped, but not all) #1
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (some escaped, but not all) #2
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (wrong escape character) #1
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (wrong escape character) #2
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (multiple characters not escaped)
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (isn't empty nor starts with /) #1
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (isn't empty nor starts with /) #2
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of JSON-pointers (JSON String Representation), not a valid JSON-pointer (isn't empty nor starts with /) #3
Original schema
{
"format": "json-pointer"
}
Schema after validating
{
"format": "json-pointer",
"id": "6760580331340371anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regular expressions, a valid regular expression
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "8798185277305146anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of regular expressions, a regular expression with unclosed parens is invalid
Original schema
{
"format": "regex"
}
Schema after validating
{
"format": "regex",
"id": "8798185277305146anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of Relative JSON Pointers (RJP), a valid upwards RJP
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "8285778277575115anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of Relative JSON Pointers (RJP), a valid downwards RJP
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "8285778277575115anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of Relative JSON Pointers (RJP), a valid up and then down RJP, with array index
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "8285778277575115anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of Relative JSON Pointers (RJP), a valid RJP taking the member or index name
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "8285778277575115anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of Relative JSON Pointers (RJP), an invalid RJP that is a valid JSON Pointer
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "8285778277575115anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of Relative JSON Pointers (RJP), negative prefix
Original schema
{
"format": "relative-json-pointer"
}
Schema after validating
{
"format": "relative-json-pointer",
"id": "8285778277575115anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, a valid time string
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "282431303252594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, an invalid time string
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "282431303252594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of time strings, only RFC3339 not all of ISO 8601 are valid
Original schema
{
"format": "time"
}
Schema after validating
{
"format": "time",
"id": "282431303252594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI References, a valid URI
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "241244152920705anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI References, a valid protocol-relative URI Reference
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "241244152920705anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI References, a valid relative URI Reference
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "241244152920705anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI References, an invalid URI Reference
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "241244152920705anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI References, a valid URI Reference
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "241244152920705anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI References, a valid URI fragment
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "241244152920705anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URI References, an invalid URI fragment
Original schema
{
"format": "uri-reference"
}
Schema after validating
{
"format": "uri-reference",
"id": "241244152920705anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test format: uri-template, a valid uri-template
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "42453886248751793anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test format: uri-template, an invalid uri-template
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "42453886248751793anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test format: uri-template, a valid uri-template without variables
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "42453886248751793anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test format: uri-template, a valid relative uri-template
Original schema
{
"format": "uri-template"
}
Schema after validating
{
"format": "uri-template",
"id": "42453886248751793anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL with anchor tag
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL with anchor tag and parantheses
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL with URL-encoded stuff
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid puny-coded URL
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL with many special characters
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL based on IPv4
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL with ftp scheme
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL for a simple text file
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URL
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid mailto URI
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid newsgroup URI
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid tel URI
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, a valid URN
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, an invalid protocol-relative URI Reference
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, an invalid relative URI Reference
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, an invalid URI
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, an invalid URI though valid URI reference
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, an invalid URI with spaces
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, an invalid URI with spaces and missing scheme
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test validation of URIs, an invalid URI with comma in scheme
Original schema
{
"format": "uri"
}
Schema after validating
{
"format": "uri",
"id": "5182071727570619anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: pattern, matches empty
Original schema
{
"pattern": "^🐲*$"
}
Schema after validating
{
"pattern": "^🐲*$",
"id": "3301134987369263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: pattern, matches single
Original schema
{
"pattern": "^🐲*$"
}
Schema after validating
{
"pattern": "^🐲*$",
"id": "3301134987369263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: pattern, matches two
Original schema
{
"pattern": "^🐲*$"
}
Schema after validating
{
"pattern": "^🐲*$",
"id": "3301134987369263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: pattern, doesn't match one
Original schema
{
"pattern": "^🐲*$"
}
Schema after validating
{
"pattern": "^🐲*$",
"id": "3301134987369263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: pattern, doesn't match two
Original schema
{
"pattern": "^🐲*$"
}
Schema after validating
{
"pattern": "^🐲*$",
"id": "3301134987369263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: pattern, doesn't match one ASCII
Original schema
{
"pattern": "^🐲*$"
}
Schema after validating
{
"pattern": "^🐲*$",
"id": "3301134987369263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: pattern, doesn't match two ASCII
Original schema
{
"pattern": "^🐲*$"
}
Schema after validating
{
"pattern": "^🐲*$",
"id": "3301134987369263anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: patternProperties, matches empty
Original schema
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
},
"id": "6893557758642008anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: patternProperties, matches single
Original schema
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
},
"id": "6893557758642008anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: patternProperties, matches two
Original schema
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
},
"id": "6893557758642008anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: patternProperties, doesn't match one
Original schema
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
},
"id": "6893557758642008anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test Proper UTF-16 surrogate pair handling: patternProperties, doesn't match two
Original schema
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"^🐲*$": {
"type": "integer"
}
},
"id": "6893557758642008anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, a matching pattern is valid
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, a non-matching pattern is invalid
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, ignores booleans
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, ignores integers
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, ignores floats
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, ignores objects
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, ignores arrays
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern validation, ignores null
Original schema
{
"pattern": "^a*$"
}
Schema after validating
{
"pattern": "^a*$",
"id": "5988942969900042anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test pattern is not anchored, matches a substring
Original schema
{
"pattern": "a+"
}
Schema after validating
{
"pattern": "a+",
"id": "9872312348225529anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test patternProperties validates properties matching a regex, a single valid match is valid
Original schema
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
},
"id": "011373806285258414anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test patternProperties validates properties matching a regex, multiple valid matches is valid
Original schema
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
},
"id": "011373806285258414anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test patternProperties validates properties matching a regex, a single invalid match is invalid
Original schema
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
},
"id": "011373806285258414anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test patternProperties validates properties matching a regex, multiple invalid matches is invalid
Original schema
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
},
"id": "011373806285258414anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test patternProperties validates properties matching a regex, ignores arrays
Original schema
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
},
"id": "011373806285258414anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test patternProperties validates properties matching a regex, ignores strings
Original schema
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
},
"id": "011373806285258414anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test patternProperties validates properties matching a regex, ignores other non-objects
Original schema
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
}
}
Schema after validating
{
"patternProperties": {
"f.*o": {
"type": "integer"
}
},
"id": "011373806285258414anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple simultaneous patternProperties are validated, a single valid match is valid
Original schema
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
}
}
Schema after validating
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
},
"id": "24809405292242404anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple simultaneous patternProperties are validated, a simultaneous match is valid
Original schema
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
}
}
Schema after validating
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
},
"id": "24809405292242404anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple simultaneous patternProperties are validated, multiple matches is valid
Original schema
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
}
}
Schema after validating
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
},
"id": "24809405292242404anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple simultaneous patternProperties are validated, an invalid due to one is invalid
Original schema
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
}
}
Schema after validating
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
},
"id": "24809405292242404anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple simultaneous patternProperties are validated, an invalid due to the other is invalid
Original schema
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
}
}
Schema after validating
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
},
"id": "24809405292242404anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple simultaneous patternProperties are validated, an invalid due to both is invalid
Original schema
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
}
}
Schema after validating
{
"patternProperties": {
"a*": {
"type": "integer"
},
"aaa*": {
"maximum": 20
}
},
"id": "24809405292242404anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test regexes are not anchored by default and are case sensitive, non recognized members are ignored
Original schema
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
}
}
Schema after validating
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
},
"id": "1133390815987787anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test regexes are not anchored by default and are case sensitive, recognized members are accounted for
Original schema
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
}
}
Schema after validating
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
},
"id": "1133390815987787anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test regexes are not anchored by default and are case sensitive, regexes are case sensitive
Original schema
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
}
}
Schema after validating
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
},
"id": "1133390815987787anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test regexes are not anchored by default and are case sensitive, regexes are case sensitive, 2
Original schema
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
}
}
Schema after validating
{
"patternProperties": {
"[0-9]{2,}": {
"type": "boolean"
},
"X_": {
"type": "string"
}
},
"id": "1133390815987787anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object properties validation, both properties present and valid is valid
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
},
"id": "5239721430423616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object properties validation, one property invalid is invalid
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
},
"id": "5239721430423616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object properties validation, both properties invalid is invalid
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
},
"id": "5239721430423616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object properties validation, doesn't invalidate other properties
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
},
"id": "5239721430423616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object properties validation, ignores arrays
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
},
"id": "5239721430423616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object properties validation, ignores other non-objects
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"type": "string"
}
},
"id": "5239721430423616anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, property validates property
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, property invalidates property
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, patternProperty invalidates property
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, patternProperty validates nonproperty
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, patternProperty invalidates nonproperty
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, additionalProperty ignores property
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, additionalProperty validates others
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test properties, patternProperties, additionalProperties interaction, additionalProperty invalidates others
Original schema
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "array",
"maxItems": 3
},
"bar": {
"type": "array"
}
},
"patternProperties": {
"f.o": {
"minItems": 2
}
},
"additionalProperties": {
"type": "integer"
},
"id": "8838029012323103anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames validation, all property names valid
Original schema
{
"propertyNames": {
"maxLength": 3
}
}
Schema after validating
{
"propertyNames": {
"maxLength": 3
},
"id": "9595243228254908anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames validation, some property names invalid
Original schema
{
"propertyNames": {
"maxLength": 3
}
}
Schema after validating
{
"propertyNames": {
"maxLength": 3
},
"id": "9595243228254908anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames validation, object without properties is valid
Original schema
{
"propertyNames": {
"maxLength": 3
}
}
Schema after validating
{
"propertyNames": {
"maxLength": 3
},
"id": "9595243228254908anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames validation, ignores arrays
Original schema
{
"propertyNames": {
"maxLength": 3
}
}
Schema after validating
{
"propertyNames": {
"maxLength": 3
},
"id": "9595243228254908anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames validation, ignores strings
Original schema
{
"propertyNames": {
"maxLength": 3
}
}
Schema after validating
{
"propertyNames": {
"maxLength": 3
},
"id": "9595243228254908anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames validation, ignores other non-objects
Original schema
{
"propertyNames": {
"maxLength": 3
}
}
Schema after validating
{
"propertyNames": {
"maxLength": 3
},
"id": "9595243228254908anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames with boolean schema true, object with any properties is valid
Original schema
{
"propertyNames": true
}
Schema after validating
{
"propertyNames": true,
"id": "4250543154748352anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames with boolean schema true, empty object is valid
Original schema
{
"propertyNames": true
}
Schema after validating
{
"propertyNames": true,
"id": "4250543154748352anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames with boolean schema false, object with any properties is invalid
Original schema
{
"propertyNames": false
}
Schema after validating
{
"propertyNames": false,
"id": "029432132366645547anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test propertyNames with boolean schema false, empty object is valid
Original schema
{
"propertyNames": false
}
Schema after validating
{
"propertyNames": false,
"id": "029432132366645547anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test root pointer ref, match
Original schema
{
"properties": {
"foo": {
"$ref": "#"
}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {
"$ref": "39610851474556696anonymous#"
}
},
"additionalProperties": false,
"id": "39610851474556696anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test root pointer ref, recursive match
Original schema
{
"properties": {
"foo": {
"$ref": "#"
}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {
"$ref": "39610851474556696anonymous#"
}
},
"additionalProperties": false,
"id": "39610851474556696anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test root pointer ref, mismatch
Original schema
{
"properties": {
"foo": {
"$ref": "#"
}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {
"$ref": "39610851474556696anonymous#"
}
},
"additionalProperties": false,
"id": "39610851474556696anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test root pointer ref, recursive mismatch
Original schema
{
"properties": {
"foo": {
"$ref": "#"
}
},
"additionalProperties": false
}
Schema after validating
{
"properties": {
"foo": {
"$ref": "39610851474556696anonymous#"
}
},
"additionalProperties": false,
"id": "39610851474556696anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test relative pointer ref to object, match
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"$ref": "#/properties/foo"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer",
"id": "6451120114829632anonymous#/properties/foo"
},
"bar": {
"$ref": "6451120114829632anonymous#/properties/foo"
}
},
"id": "6451120114829632anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test relative pointer ref to object, mismatch
Original schema
{
"properties": {
"foo": {
"type": "integer"
},
"bar": {
"$ref": "#/properties/foo"
}
}
}
Schema after validating
{
"properties": {
"foo": {
"type": "integer",
"id": "6451120114829632anonymous#/properties/foo"
},
"bar": {
"$ref": "6451120114829632anonymous#/properties/foo"
}
},
"id": "6451120114829632anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test relative pointer ref to array, match array
Original schema
{
"items": [
{
"type": "integer"
},
{
"$ref": "#/items/0"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer",
"id": "07692346905321457anonymous#/items/0"
},
{
"$ref": "07692346905321457anonymous#/items/0"
}
],
"id": "07692346905321457anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test relative pointer ref to array, mismatch array
Original schema
{
"items": [
{
"type": "integer"
},
{
"$ref": "#/items/0"
}
]
}
Schema after validating
{
"items": [
{
"type": "integer",
"id": "07692346905321457anonymous#/items/0"
},
{
"$ref": "07692346905321457anonymous#/items/0"
}
],
"id": "07692346905321457anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test escaped pointer ref, slash invalid
Original schema
{
"definitions": {
"tilde~field": {
"type": "integer"
},
"slash/field": {
"type": "integer"
},
"percent%field": {
"type": "integer"
}
},
"properties": {
"tilde": {
"$ref": "#/definitions/tilde~0field"
},
"slash": {
"$ref": "#/definitions/slash~1field"
},
"percent": {
"$ref": "#/definitions/percent%25field"
}
}
}
Schema after validating
{
"definitions": {
"tilde~field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash/field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent%field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"properties": {
"tilde": {
"$ref": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash": {
"$ref": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent": {
"$ref": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"id": "013422573903398183anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test escaped pointer ref, tilde invalid
Original schema
{
"definitions": {
"tilde~field": {
"type": "integer"
},
"slash/field": {
"type": "integer"
},
"percent%field": {
"type": "integer"
}
},
"properties": {
"tilde": {
"$ref": "#/definitions/tilde~0field"
},
"slash": {
"$ref": "#/definitions/slash~1field"
},
"percent": {
"$ref": "#/definitions/percent%25field"
}
}
}
Schema after validating
{
"definitions": {
"tilde~field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash/field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent%field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"properties": {
"tilde": {
"$ref": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash": {
"$ref": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent": {
"$ref": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"id": "013422573903398183anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test escaped pointer ref, percent invalid
Original schema
{
"definitions": {
"tilde~field": {
"type": "integer"
},
"slash/field": {
"type": "integer"
},
"percent%field": {
"type": "integer"
}
},
"properties": {
"tilde": {
"$ref": "#/definitions/tilde~0field"
},
"slash": {
"$ref": "#/definitions/slash~1field"
},
"percent": {
"$ref": "#/definitions/percent%25field"
}
}
}
Schema after validating
{
"definitions": {
"tilde~field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash/field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent%field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"properties": {
"tilde": {
"$ref": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash": {
"$ref": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent": {
"$ref": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"id": "013422573903398183anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test escaped pointer ref, slash valid
Original schema
{
"definitions": {
"tilde~field": {
"type": "integer"
},
"slash/field": {
"type": "integer"
},
"percent%field": {
"type": "integer"
}
},
"properties": {
"tilde": {
"$ref": "#/definitions/tilde~0field"
},
"slash": {
"$ref": "#/definitions/slash~1field"
},
"percent": {
"$ref": "#/definitions/percent%25field"
}
}
}
Schema after validating
{
"definitions": {
"tilde~field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash/field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent%field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"properties": {
"tilde": {
"$ref": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash": {
"$ref": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent": {
"$ref": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"id": "013422573903398183anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test escaped pointer ref, tilde valid
Original schema
{
"definitions": {
"tilde~field": {
"type": "integer"
},
"slash/field": {
"type": "integer"
},
"percent%field": {
"type": "integer"
}
},
"properties": {
"tilde": {
"$ref": "#/definitions/tilde~0field"
},
"slash": {
"$ref": "#/definitions/slash~1field"
},
"percent": {
"$ref": "#/definitions/percent%25field"
}
}
}
Schema after validating
{
"definitions": {
"tilde~field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash/field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent%field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"properties": {
"tilde": {
"$ref": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash": {
"$ref": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent": {
"$ref": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"id": "013422573903398183anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test escaped pointer ref, percent valid
Original schema
{
"definitions": {
"tilde~field": {
"type": "integer"
},
"slash/field": {
"type": "integer"
},
"percent%field": {
"type": "integer"
}
},
"properties": {
"tilde": {
"$ref": "#/definitions/tilde~0field"
},
"slash": {
"$ref": "#/definitions/slash~1field"
},
"percent": {
"$ref": "#/definitions/percent%25field"
}
}
}
Schema after validating
{
"definitions": {
"tilde~field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash/field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent%field": {
"type": "integer",
"id": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"properties": {
"tilde": {
"$ref": "013422573903398183anonymous#/definitions/tilde~0field"
},
"slash": {
"$ref": "013422573903398183anonymous#/definitions/slash~1field"
},
"percent": {
"$ref": "013422573903398183anonymous#/definitions/percent%25field"
}
},
"id": "013422573903398183anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested refs, nested ref valid
Original schema
{
"definitions": {
"a": {
"type": "integer"
},
"b": {
"$ref": "#/definitions/a"
},
"c": {
"$ref": "#/definitions/b"
}
},
"$ref": "#/definitions/c"
}
Schema after validating
{
"definitions": {
"a": {
"type": "integer"
},
"b": {
"$ref": "7202788185001192anonymous#/definitions/a"
},
"c": {
"$ref": "7202788185001192anonymous#/definitions/b"
}
},
"$ref": "7202788185001192anonymous#/definitions/c",
"id": "7202788185001192anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test nested refs, nested ref invalid
Original schema
{
"definitions": {
"a": {
"type": "integer"
},
"b": {
"$ref": "#/definitions/a"
},
"c": {
"$ref": "#/definitions/b"
}
},
"$ref": "#/definitions/c"
}
Schema after validating
{
"definitions": {
"a": {
"type": "integer"
},
"b": {
"$ref": "7202788185001192anonymous#/definitions/a"
},
"c": {
"$ref": "7202788185001192anonymous#/definitions/b"
}
},
"$ref": "7202788185001192anonymous#/definitions/c",
"id": "7202788185001192anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ref overrides any sibling keywords, ref valid
Original schema
{
"definitions": {
"reffed": {
"type": "array"
}
},
"properties": {
"foo": {
"$ref": "#/definitions/reffed",
"maxItems": 2
}
}
}
Schema after validating
{
"definitions": {
"reffed": {
"type": "array",
"id": "7122350993428166anonymous#/definitions/reffed"
}
},
"properties": {
"foo": {
"$ref": "7122350993428166anonymous#/definitions/reffed",
"maxItems": 2
}
},
"id": "7122350993428166anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ref overrides any sibling keywords, ref valid, maxItems ignored
Original schema
{
"definitions": {
"reffed": {
"type": "array"
}
},
"properties": {
"foo": {
"$ref": "#/definitions/reffed",
"maxItems": 2
}
}
}
Schema after validating
{
"definitions": {
"reffed": {
"type": "array",
"id": "7122350993428166anonymous#/definitions/reffed"
}
},
"properties": {
"foo": {
"$ref": "7122350993428166anonymous#/definitions/reffed",
"maxItems": 2
}
},
"id": "7122350993428166anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ref overrides any sibling keywords, ref invalid
Original schema
{
"definitions": {
"reffed": {
"type": "array"
}
},
"properties": {
"foo": {
"$ref": "#/definitions/reffed",
"maxItems": 2
}
}
}
Schema after validating
{
"definitions": {
"reffed": {
"type": "array",
"id": "7122350993428166anonymous#/definitions/reffed"
}
},
"properties": {
"foo": {
"$ref": "7122350993428166anonymous#/definitions/reffed",
"maxItems": 2
}
},
"id": "7122350993428166anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test remote ref, containing refs itself, remote ref valid
Original schema
{
"$ref": "http://json-schema.org/draft-07/schema#"
}
Schema after validating
{
"$ref": "http://json-schema.org/draft-07/schema#",
"id": "45345860446991915anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test remote ref, containing refs itself, remote ref invalid
Original schema
{
"$ref": "http://json-schema.org/draft-07/schema#"
}
Schema after validating
{
"$ref": "http://json-schema.org/draft-07/schema#",
"id": "45345860446991915anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test property named $ref that is not a reference, property named $ref valid
Original schema
{
"properties": {
"$ref": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"$ref": {
"type": "string"
}
},
"id": "06709811996165937anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test property named $ref that is not a reference, property named $ref invalid
Original schema
{
"properties": {
"$ref": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"$ref": {
"type": "string"
}
},
"id": "06709811996165937anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test property named $ref, containing an actual $ref, property named $ref valid
Original schema
{
"properties": {
"$ref": {
"$ref": "#/definitions/is-string"
}
},
"definitions": {
"is-string": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"$ref": {
"$ref": "833437048081753anonymous#/definitions/is-string"
}
},
"definitions": {
"is-string": {
"type": "string",
"id": "833437048081753anonymous#/definitions/is-string"
}
},
"id": "833437048081753anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test property named $ref, containing an actual $ref, property named $ref invalid
Original schema
{
"properties": {
"$ref": {
"$ref": "#/definitions/is-string"
}
},
"definitions": {
"is-string": {
"type": "string"
}
}
}
Schema after validating
{
"properties": {
"$ref": {
"$ref": "833437048081753anonymous#/definitions/is-string"
}
},
"definitions": {
"is-string": {
"type": "string",
"id": "833437048081753anonymous#/definitions/is-string"
}
},
"id": "833437048081753anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test $ref to boolean schema false, any value is invalid
Original schema
{
"$ref": "#/definitions/bool",
"definitions": {
"bool": false
}
}
Schema after validating
{
"$ref": "6298867268110404anonymous#/definitions/bool",
"definitions": {
"bool": false
},
"id": "6298867268110404anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test naive replacement of $ref with its destination is not correct, do not evaluate the $ref inside the enum
Original schema
{
"definitions": {
"a_string": {
"type": "string"
}
},
"enum": [
{
"$ref": "#/definitions/a_string"
}
]
}
Schema after validating
{
"definitions": {
"a_string": {
"type": "string"
}
},
"enum": [
{
"$ref": "#/definitions/a_string"
}
],
"id": "10819770752847035anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test naive replacement of $ref with its destination is not correct, match the enum exactly
Original schema
{
"definitions": {
"a_string": {
"type": "string"
}
},
"enum": [
{
"$ref": "#/definitions/a_string"
}
]
}
Schema after validating
{
"definitions": {
"a_string": {
"type": "string"
}
},
"enum": [
{
"$ref": "#/definitions/a_string"
}
],
"id": "10819770752847035anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ref within remote ref, ref within ref valid
Original schema
{
"$ref": "http://localhost:1234/subSchemas.json#/refToInteger"
}
Schema after validating
{
"$ref": "http://localhost:1234/subSchemas.json#/refToInteger",
"id": "2719170355299032anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test ref within remote ref, ref within ref invalid
Original schema
{
"$ref": "http://localhost:1234/subSchemas.json#/refToInteger"
}
Schema after validating
{
"$ref": "http://localhost:1234/subSchemas.json#/refToInteger",
"id": "2719170355299032anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test base URI change - change folder, number is valid
Original schema
{
"$id": "http://localhost:1234/scope_change_defs1.json",
"type": "object",
"properties": {
"list": {
"$ref": "#/definitions/baz"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolder/",
"type": "array",
"items": {
"$ref": "folderInteger.json"
}
}
}
}
Schema after validating
{
"$id": "http://localhost:1234/scope_change_defs1.json",
"type": "object",
"properties": {
"list": {
"$ref": "31975577910840514anonymous#/definitions/baz"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolder/",
"type": "array",
"items": {
"$ref": "folderInteger.json"
},
"id": "31975577910840514anonymous#/definitions/baz"
}
},
"id": "31975577910840514anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test base URI change - change folder, string is invalid
Original schema
{
"$id": "http://localhost:1234/scope_change_defs1.json",
"type": "object",
"properties": {
"list": {
"$ref": "#/definitions/baz"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolder/",
"type": "array",
"items": {
"$ref": "folderInteger.json"
}
}
}
}
Schema after validating
{
"$id": "http://localhost:1234/scope_change_defs1.json",
"type": "object",
"properties": {
"list": {
"$ref": "31975577910840514anonymous#/definitions/baz"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolder/",
"type": "array",
"items": {
"$ref": "folderInteger.json"
},
"id": "31975577910840514anonymous#/definitions/baz"
}
},
"id": "31975577910840514anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test base URI change - change folder in subschema, number is valid
Original schema
{
"$id": "http://localhost:1234/scope_change_defs2.json",
"type": "object",
"properties": {
"list": {
"$ref": "#/definitions/baz/definitions/bar"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolderInSubschema/",
"definitions": {
"bar": {
"type": "array",
"items": {
"$ref": "folderInteger.json"
}
}
}
}
}
}
Schema after validating
{
"$id": "http://localhost:1234/scope_change_defs2.json",
"type": "object",
"properties": {
"list": {
"$ref": "46688184928805376anonymous#/definitions/baz/definitions/bar"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolderInSubschema/",
"definitions": {
"bar": {
"type": "array",
"items": {
"$ref": "folderInteger.json"
},
"id": "46688184928805376anonymous#/definitions/baz/definitions/bar"
}
}
}
},
"id": "46688184928805376anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test base URI change - change folder in subschema, string is invalid
Original schema
{
"$id": "http://localhost:1234/scope_change_defs2.json",
"type": "object",
"properties": {
"list": {
"$ref": "#/definitions/baz/definitions/bar"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolderInSubschema/",
"definitions": {
"bar": {
"type": "array",
"items": {
"$ref": "folderInteger.json"
}
}
}
}
}
}
Schema after validating
{
"$id": "http://localhost:1234/scope_change_defs2.json",
"type": "object",
"properties": {
"list": {
"$ref": "46688184928805376anonymous#/definitions/baz/definitions/bar"
}
},
"definitions": {
"baz": {
"$id": "baseUriChangeFolderInSubschema/",
"definitions": {
"bar": {
"type": "array",
"items": {
"$ref": "folderInteger.json"
},
"id": "46688184928805376anonymous#/definitions/baz/definitions/bar"
}
}
}
},
"id": "46688184928805376anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required validation, present required property is valid
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
]
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
],
"id": "8290871755693463anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required validation, non-present required property is invalid
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
]
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
],
"id": "8290871755693463anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required validation, ignores arrays
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
]
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
],
"id": "8290871755693463anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required validation, ignores strings
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
]
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
],
"id": "8290871755693463anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required validation, ignores other non-objects
Original schema
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
]
}
Schema after validating
{
"properties": {
"foo": {},
"bar": {}
},
"required": [
"foo"
],
"id": "8290871755693463anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required default validation, not required by default
Original schema
{
"properties": {
"foo": {}
}
}
Schema after validating
{
"properties": {
"foo": {}
},
"id": "8322069247763741anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required with empty array, property not required
Original schema
{
"properties": {
"foo": {}
},
"required": []
}
Schema after validating
{
"properties": {
"foo": {}
},
"required": [],
"id": "8957822419726871anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required with escaped characters, object with all properties present is valid
Original schema
{
"required": [
"foo\nbar",
"foo\"bar",
"foo\\bar",
"foo\rbar",
"foo\tbar",
"foo\fbar"
]
}
Schema after validating
{
"required": [
"foo\nbar",
"foo\"bar",
"foo\\bar",
"foo\rbar",
"foo\tbar",
"foo\fbar"
],
"id": "15272451530213438anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test required with escaped characters, object with some properties missing is invalid
Original schema
{
"required": [
"foo\nbar",
"foo\"bar",
"foo\\bar",
"foo\rbar",
"foo\tbar",
"foo\fbar"
]
}
Schema after validating
{
"required": [
"foo\nbar",
"foo\"bar",
"foo\\bar",
"foo\rbar",
"foo\tbar",
"foo\fbar"
],
"id": "15272451530213438anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, an integer is an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, a float with zero fractional part is an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, a float is not an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, a string is not an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, a string is still not an integer, even if it looks like one
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, an object is not an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, an array is not an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, a boolean is not an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test integer type matches integers, null is not an integer
Original schema
{
"type": "integer"
}
Schema after validating
{
"type": "integer",
"id": "6729347026195849anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, an integer is a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, a float with zero fractional part is a number (and an integer)
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, a float is a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, a string is not a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, a string is still not a number, even if it looks like one
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, an object is not a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, an array is not a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, a boolean is not a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test number type matches numbers, null is not a number
Original schema
{
"type": "number"
}
Schema after validating
{
"type": "number",
"id": "658805387085033anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, 1 is not a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, a float is not a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, a string is a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, a string is still a string, even if it looks like a number
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, an empty string is still a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, an object is not a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, an array is not a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, a boolean is not a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test string type matches strings, null is not a string
Original schema
{
"type": "string"
}
Schema after validating
{
"type": "string",
"id": "6077799347503967anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object type matches objects, an integer is not an object
Original schema
{
"type": "object"
}
Schema after validating
{
"type": "object",
"id": "7279289408645284anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object type matches objects, a float is not an object
Original schema
{
"type": "object"
}
Schema after validating
{
"type": "object",
"id": "7279289408645284anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object type matches objects, a string is not an object
Original schema
{
"type": "object"
}
Schema after validating
{
"type": "object",
"id": "7279289408645284anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object type matches objects, an object is an object
Original schema
{
"type": "object"
}
Schema after validating
{
"type": "object",
"id": "7279289408645284anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object type matches objects, an array is not an object
Original schema
{
"type": "object"
}
Schema after validating
{
"type": "object",
"id": "7279289408645284anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object type matches objects, a boolean is not an object
Original schema
{
"type": "object"
}
Schema after validating
{
"type": "object",
"id": "7279289408645284anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test object type matches objects, null is not an object
Original schema
{
"type": "object"
}
Schema after validating
{
"type": "object",
"id": "7279289408645284anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array type matches arrays, an integer is not an array
Original schema
{
"type": "array"
}
Schema after validating
{
"type": "array",
"id": "17507208004722208anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array type matches arrays, a float is not an array
Original schema
{
"type": "array"
}
Schema after validating
{
"type": "array",
"id": "17507208004722208anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array type matches arrays, a string is not an array
Original schema
{
"type": "array"
}
Schema after validating
{
"type": "array",
"id": "17507208004722208anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array type matches arrays, an object is not an array
Original schema
{
"type": "array"
}
Schema after validating
{
"type": "array",
"id": "17507208004722208anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array type matches arrays, an array is an array
Original schema
{
"type": "array"
}
Schema after validating
{
"type": "array",
"id": "17507208004722208anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array type matches arrays, a boolean is not an array
Original schema
{
"type": "array"
}
Schema after validating
{
"type": "array",
"id": "17507208004722208anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test array type matches arrays, null is not an array
Original schema
{
"type": "array"
}
Schema after validating
{
"type": "array",
"id": "17507208004722208anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, an integer is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, zero is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, a float is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, a string is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, an empty string is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, an object is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, an array is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, true is a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, false is a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test boolean type matches booleans, null is not a boolean
Original schema
{
"type": "boolean"
}
Schema after validating
{
"type": "boolean",
"id": "7441686578269331anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, an integer is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, a float is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, zero is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, a string is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, an empty string is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, an object is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, an array is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, true is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, false is not null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test null type matches only the null object, null is null
Original schema
{
"type": "null"
}
Schema after validating
{
"type": "null",
"id": "5847479141704301anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple types can be specified in an array, an integer is valid
Original schema
{
"type": [
"integer",
"string"
]
}
Schema after validating
{
"type": [
"integer",
"string"
],
"id": "7318261342211141anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple types can be specified in an array, a string is valid
Original schema
{
"type": [
"integer",
"string"
]
}
Schema after validating
{
"type": [
"integer",
"string"
],
"id": "7318261342211141anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple types can be specified in an array, a float is invalid
Original schema
{
"type": [
"integer",
"string"
]
}
Schema after validating
{
"type": [
"integer",
"string"
],
"id": "7318261342211141anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple types can be specified in an array, an object is invalid
Original schema
{
"type": [
"integer",
"string"
]
}
Schema after validating
{
"type": [
"integer",
"string"
],
"id": "7318261342211141anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple types can be specified in an array, an array is invalid
Original schema
{
"type": [
"integer",
"string"
]
}
Schema after validating
{
"type": [
"integer",
"string"
],
"id": "7318261342211141anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple types can be specified in an array, a boolean is invalid
Original schema
{
"type": [
"integer",
"string"
]
}
Schema after validating
{
"type": [
"integer",
"string"
],
"id": "7318261342211141anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test multiple types can be specified in an array, null is invalid
Original schema
{
"type": [
"integer",
"string"
]
}
Schema after validating
{
"type": [
"integer",
"string"
],
"id": "7318261342211141anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type as array with one item, string is valid
Original schema
{
"type": [
"string"
]
}
Schema after validating
{
"type": [
"string"
],
"id": "06375911772269682anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type as array with one item, number is invalid
Original schema
{
"type": [
"string"
]
}
Schema after validating
{
"type": [
"string"
],
"id": "06375911772269682anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array or object, array is valid
Original schema
{
"type": [
"array",
"object"
]
}
Schema after validating
{
"type": [
"array",
"object"
],
"id": "45172236518959186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array or object, object is valid
Original schema
{
"type": [
"array",
"object"
]
}
Schema after validating
{
"type": [
"array",
"object"
],
"id": "45172236518959186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array or object, number is invalid
Original schema
{
"type": [
"array",
"object"
]
}
Schema after validating
{
"type": [
"array",
"object"
],
"id": "45172236518959186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array or object, string is invalid
Original schema
{
"type": [
"array",
"object"
]
}
Schema after validating
{
"type": [
"array",
"object"
],
"id": "45172236518959186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array or object, null is invalid
Original schema
{
"type": [
"array",
"object"
]
}
Schema after validating
{
"type": [
"array",
"object"
],
"id": "45172236518959186anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array, object or null, array is valid
Original schema
{
"type": [
"array",
"object",
"null"
]
}
Schema after validating
{
"type": [
"array",
"object",
"null"
],
"id": "5542405760280924anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array, object or null, object is valid
Original schema
{
"type": [
"array",
"object",
"null"
]
}
Schema after validating
{
"type": [
"array",
"object",
"null"
],
"id": "5542405760280924anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array, object or null, null is valid
Original schema
{
"type": [
"array",
"object",
"null"
]
}
Schema after validating
{
"type": [
"array",
"object",
"null"
],
"id": "5542405760280924anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array, object or null, number is invalid
Original schema
{
"type": [
"array",
"object",
"null"
]
}
Schema after validating
{
"type": [
"array",
"object",
"null"
],
"id": "5542405760280924anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test type: array, object or null, string is invalid
Original schema
{
"type": [
"array",
"object",
"null"
]
}
Schema after validating
{
"type": [
"array",
"object",
"null"
],
"id": "5542405760280924anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, unique array of integers is valid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, non-unique array of integers is invalid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, numbers are unique if mathematically unequal
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, false is not equal to zero
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, true is not equal to one
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, unique array of objects is valid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, non-unique array of objects is invalid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, unique array of nested objects is valid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, non-unique array of nested objects is invalid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, unique array of arrays is valid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, non-unique array of arrays is invalid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, 1 and true are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, 0 and false are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, [1] and [true] are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, [0] and [false] are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, nested [1] and [true] are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, nested [0] and [false] are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, unique heterogeneous types are valid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, non-unique heterogeneous types are invalid
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, different objects are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, objects are non-unique despite key order
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, {"a": false} and {"a": 0} are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems validation, {"a": true} and {"a": 1} are unique
Original schema
{
"uniqueItems": true
}
Schema after validating
{
"uniqueItems": true,
"id": "9536047030008594anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, [false, true] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, [true, false] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, [false, false] from items array is not valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, [true, true] from items array is not valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, unique array extended from [false, true] is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, unique array extended from [true, false] is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, non-unique array extended from [false, true] is not valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items, non-unique array extended from [true, false] is not valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"id": "8367566688836399anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items and additionalItems=false, [false, true] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false,
"id": "05302228765515471anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items and additionalItems=false, [true, false] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false,
"id": "05302228765515471anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items and additionalItems=false, [false, false] from items array is not valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false,
"id": "05302228765515471anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items and additionalItems=false, [true, true] from items array is not valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false,
"id": "05302228765515471anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems with an array of items and additionalItems=false, extra items are invalid even if unique
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": true,
"additionalItems": false,
"id": "05302228765515471anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, unique array of integers is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, non-unique array of integers is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, numbers are unique if mathematically unequal
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, false is not equal to zero
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, true is not equal to one
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, unique array of objects is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, non-unique array of objects is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, unique array of nested objects is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, non-unique array of nested objects is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, unique array of arrays is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, non-unique array of arrays is valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, 1 and true are unique
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, 0 and false are unique
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, unique heterogeneous types are valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false validation, non-unique heterogeneous types are valid
Original schema
{
"uniqueItems": false
}
Schema after validating
{
"uniqueItems": false,
"id": "4032586499177573anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, [false, true] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, [true, false] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, [false, false] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, [true, true] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, unique array extended from [false, true] is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, unique array extended from [true, false] is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, non-unique array extended from [false, true] is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items, non-unique array extended from [true, false] is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"id": "654247498994422anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items and additionalItems=false, [false, true] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false,
"id": "7402840246287927anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items and additionalItems=false, [true, false] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false,
"id": "7402840246287927anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items and additionalItems=false, [false, false] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false,
"id": "7402840246287927anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items and additionalItems=false, [true, true] from items array is valid
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false,
"id": "7402840246287927anonymous"
}
Side-effect on schema
json-model had a side-effect on (altered the original) schema in the test uniqueItems=false with an array of items and additionalItems=false, extra items are invalid even if unique
Original schema
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false
}
Schema after validating
{
"items": [
{
"type": "boolean"
},
{
"type": "boolean"
}
],
"uniqueItems": false,
"additionalItems": false,
"id": "7402840246287927anonymous"
}