When running tests revalidator mutated either the original schema or the data being validated with the schema or both.

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": {}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test allOf with boolean schemas, all true, any value is valid

Original schema

{
	"allOf": [
		true,
		true
	]
}

Schema after validating

{
	"allOf": [
		true,
		true
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test allOf with boolean schemas, some false, any value is invalid

Original schema

{
	"allOf": [
		true,
		false
	]
}

Schema after validating

{
	"allOf": [
		true,
		false
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": [
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": [
		{},
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test anyOf with boolean schemas, all true, any value is valid

Original schema

{
	"anyOf": [
		true,
		true
	]
}

Schema after validating

{
	"anyOf": [
		true,
		true
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test anyOf with boolean schemas, some true, any value is valid

Original schema

{
	"anyOf": [
		true,
		false
	]
}

Schema after validating

{
	"anyOf": [
		true,
		false
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": []
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": []
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test valid definition, valid definition schema

Original schema

{
	"$ref": "http://json-schema.org/draft-06/schema#"
}

Schema after validating

{
	"$ref": "http://json-schema.org/draft-06/schema#",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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-06/schema#"
}

Schema after validating

{
	"$ref": "http://json-schema.org/draft-06/schema#",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": []
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": []
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": []
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test dependencies with boolean subschemas, object with property having schema true is valid

Original schema

{
	"dependencies": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"dependencies": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test dependencies with boolean subschemas, object with property having schema false is invalid

Original schema

{
	"dependencies": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"dependencies": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test dependencies with boolean subschemas, object with both properties is invalid

Original schema

{
	"dependencies": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"dependencies": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test dependencies with boolean subschemas, empty object is valid

Original schema

{
	"dependencies": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"dependencies": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"allOf": [
		{
			"properties": {
				"foo": {
					"$ref": "#/definitions/int"
				}
			}
		},
		{
			"additionalProperties": {
				"$ref": "#/definitions/int"
			}
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"allOf": [
		{
			"properties": {
				"foo": {
					"$ref": "#/definitions/int"
				}
			}
		},
		{
			"additionalProperties": {
				"$ref": "#/definitions/int"
			}
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test items with boolean schemas, array with one item is valid

Original schema

{
	"items": [
		true,
		false
	]
}

Schema after validating

{
	"items": [
		true,
		false
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test items with boolean schemas, array with two items is invalid

Original schema

{
	"items": [
		true,
		false
	]
}

Schema after validating

{
	"items": [
		true,
		false
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test items with boolean schemas, empty array is valid

Original schema

{
	"items": [
		true,
		false
	]
}

Schema after validating

{
	"items": [
		true,
		false
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		]
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": {}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": {}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test oneOf with boolean schemas, all true, any value is invalid

Original schema

{
	"oneOf": [
		true,
		true,
		true
	]
}

Schema after validating

{
	"oneOf": [
		true,
		true,
		true
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test oneOf with boolean schemas, one true, any value is valid

Original schema

{
	"oneOf": [
		true,
		false,
		false
	]
}

Schema after validating

{
	"oneOf": [
		true,
		false,
		false
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test oneOf with boolean schemas, more than one true, any value is invalid

Original schema

{
	"oneOf": [
		true,
		true,
		false
	]
}

Schema after validating

{
	"oneOf": [
		true,
		true,
		false
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test oneOf with missing optional property, first oneOf valid

Original schema

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	]
}

Schema after validating

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test oneOf with missing optional property, second oneOf valid

Original schema

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	]
}

Schema after validating

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test oneOf with missing optional property, both oneOf valid

Original schema

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	]
}

Schema after validating

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test oneOf with missing optional property, neither oneOf valid

Original schema

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	]
}

Schema after validating

{
	"oneOf": [
		{
			"properties": {
				"bar": true,
				"baz": true
			},
			"required": [
				"bar"
			]
		},
		{
			"properties": {
				"foo": true
			},
			"required": [
				"foo"
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
				}
			]
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test validation of date-time strings, an invalid closing Z after time-zone offset

Original schema

{
	"format": "date-time"
}

Schema after validating

{
	"format": "date-time",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "^🐲*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "^🐲*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "^🐲*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "^🐲*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "^🐲*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "^🐲*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "^🐲*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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*$",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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+",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test patternProperties with boolean schemas, object with property matching schema true is valid

Original schema

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	}
}

Schema after validating

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test patternProperties with boolean schemas, object with property matching schema false is invalid

Original schema

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	}
}

Schema after validating

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test patternProperties with boolean schemas, object with both properties is invalid

Original schema

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	}
}

Schema after validating

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test patternProperties with boolean schemas, object with a property matching both true and false is invalid

Original schema

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	}
}

Schema after validating

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test patternProperties with boolean schemas, empty object is valid

Original schema

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	}
}

Schema after validating

{
	"patternProperties": {
		"f.*": true,
		"b.*": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test properties with boolean schema, no property present is valid

Original schema

{
	"properties": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"properties": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test properties with boolean schema, only 'true' property present is valid

Original schema

{
	"properties": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"properties": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test properties with boolean schema, only 'false' property present is invalid

Original schema

{
	"properties": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"properties": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test properties with boolean schema, both properties present is invalid

Original schema

{
	"properties": {
		"foo": true,
		"bar": false
	}
}

Schema after validating

{
	"properties": {
		"foo": true,
		"bar": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test properties with escaped characters, object with all numbers is valid

Original schema

{
	"properties": {
		"foo\nbar": {
			"type": "number"
		},
		"foo\"bar": {
			"type": "number"
		},
		"foo\\bar": {
			"type": "number"
		},
		"foo\rbar": {
			"type": "number"
		},
		"foo\tbar": {
			"type": "number"
		},
		"foo\fbar": {
			"type": "number"
		}
	}
}

Schema after validating

{
	"properties": {
		"foo\nbar": {
			"type": "number"
		},
		"foo\"bar": {
			"type": "number"
		},
		"foo\\bar": {
			"type": "number"
		},
		"foo\rbar": {
			"type": "number"
		},
		"foo\tbar": {
			"type": "number"
		},
		"foo\fbar": {
			"type": "number"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test properties with escaped characters, object with strings is invalid

Original schema

{
	"properties": {
		"foo\nbar": {
			"type": "number"
		},
		"foo\"bar": {
			"type": "number"
		},
		"foo\\bar": {
			"type": "number"
		},
		"foo\rbar": {
			"type": "number"
		},
		"foo\tbar": {
			"type": "number"
		},
		"foo\fbar": {
			"type": "number"
		}
	}
}

Schema after validating

{
	"properties": {
		"foo\nbar": {
			"type": "number"
		},
		"foo\"bar": {
			"type": "number"
		},
		"foo\\bar": {
			"type": "number"
		},
		"foo\rbar": {
			"type": "number"
		},
		"foo\tbar": {
			"type": "number"
		},
		"foo\fbar": {
			"type": "number"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"bar": {
			"$ref": "#/properties/foo"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"bar": {
			"$ref": "#/properties/foo"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{
			"$ref": "#/items/0"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		{
			"$ref": "#/items/0"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"slash/field": {
			"type": "integer"
		},
		"percent%field": {
			"type": "integer"
		}
	},
	"properties": {
		"tilde": {
			"$ref": "#/definitions/tilde~0field"
		},
		"slash": {
			"$ref": "#/definitions/slash~1field"
		},
		"percent": {
			"$ref": "#/definitions/percent%25field"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"slash/field": {
			"type": "integer"
		},
		"percent%field": {
			"type": "integer"
		}
	},
	"properties": {
		"tilde": {
			"$ref": "#/definitions/tilde~0field"
		},
		"slash": {
			"$ref": "#/definitions/slash~1field"
		},
		"percent": {
			"$ref": "#/definitions/percent%25field"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"slash/field": {
			"type": "integer"
		},
		"percent%field": {
			"type": "integer"
		}
	},
	"properties": {
		"tilde": {
			"$ref": "#/definitions/tilde~0field"
		},
		"slash": {
			"$ref": "#/definitions/slash~1field"
		},
		"percent": {
			"$ref": "#/definitions/percent%25field"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"slash/field": {
			"type": "integer"
		},
		"percent%field": {
			"type": "integer"
		}
	},
	"properties": {
		"tilde": {
			"$ref": "#/definitions/tilde~0field"
		},
		"slash": {
			"$ref": "#/definitions/slash~1field"
		},
		"percent": {
			"$ref": "#/definitions/percent%25field"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"slash/field": {
			"type": "integer"
		},
		"percent%field": {
			"type": "integer"
		}
	},
	"properties": {
		"tilde": {
			"$ref": "#/definitions/tilde~0field"
		},
		"slash": {
			"$ref": "#/definitions/slash~1field"
		},
		"percent": {
			"$ref": "#/definitions/percent%25field"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		},
		"slash/field": {
			"type": "integer"
		},
		"percent%field": {
			"type": "integer"
		}
	},
	"properties": {
		"tilde": {
			"$ref": "#/definitions/tilde~0field"
		},
		"slash": {
			"$ref": "#/definitions/slash~1field"
		},
		"percent": {
			"$ref": "#/definitions/percent%25field"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/a"
		},
		"c": {
			"$ref": "#/definitions/b"
		}
	},
	"$ref": "#/definitions/c",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/a"
		},
		"c": {
			"$ref": "#/definitions/b"
		}
	},
	"$ref": "#/definitions/c",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"properties": {
		"foo": {
			"$ref": "#/definitions/reffed",
			"maxItems": 2
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"properties": {
		"foo": {
			"$ref": "#/definitions/reffed",
			"maxItems": 2
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"properties": {
		"foo": {
			"$ref": "#/definitions/reffed",
			"maxItems": 2
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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-06/schema#"
}

Schema after validating

{
	"$ref": "http://json-schema.org/draft-06/schema#",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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-06/schema#"
}

Schema after validating

{
	"$ref": "http://json-schema.org/draft-06/schema#",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/is-string"
		}
	},
	"definitions": {
		"is-string": {
			"type": "string"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/is-string"
		}
	},
	"definitions": {
		"is-string": {
			"type": "string"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test $ref to boolean schema true, any value is valid

Original schema

{
	"$ref": "#/definitions/bool",
	"definitions": {
		"bool": true
	}
}

Schema after validating

{
	"$ref": "#/definitions/bool",
	"definitions": {
		"bool": true
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/bool",
	"definitions": {
		"bool": false
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Recursive references between schemas, valid tree

Original schema

{
	"$id": "http://localhost:1234/tree",
	"description": "tree of nodes",
	"type": "object",
	"properties": {
		"meta": {
			"type": "string"
		},
		"nodes": {
			"type": "array",
			"items": {
				"$ref": "node"
			}
		}
	},
	"required": [
		"meta",
		"nodes"
	],
	"definitions": {
		"node": {
			"$id": "http://localhost:1234/node",
			"description": "node",
			"type": "object",
			"properties": {
				"value": {
					"type": "number"
				},
				"subtree": {
					"$ref": "tree"
				}
			},
			"required": [
				"value"
			]
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/tree",
	"description": "tree of nodes",
	"type": "object",
	"properties": {
		"meta": {
			"type": "string"
		},
		"nodes": {
			"type": "array",
			"items": {
				"$ref": "node"
			}
		}
	},
	"required": [
		"meta",
		"nodes"
	],
	"definitions": {
		"node": {
			"$id": "http://localhost:1234/node",
			"description": "node",
			"type": "object",
			"properties": {
				"value": {
					"type": "number"
				},
				"subtree": {
					"$ref": "tree"
				}
			},
			"required": [
				"value"
			]
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Recursive references between schemas, invalid tree

Original schema

{
	"$id": "http://localhost:1234/tree",
	"description": "tree of nodes",
	"type": "object",
	"properties": {
		"meta": {
			"type": "string"
		},
		"nodes": {
			"type": "array",
			"items": {
				"$ref": "node"
			}
		}
	},
	"required": [
		"meta",
		"nodes"
	],
	"definitions": {
		"node": {
			"$id": "http://localhost:1234/node",
			"description": "node",
			"type": "object",
			"properties": {
				"value": {
					"type": "number"
				},
				"subtree": {
					"$ref": "tree"
				}
			},
			"required": [
				"value"
			]
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/tree",
	"description": "tree of nodes",
	"type": "object",
	"properties": {
		"meta": {
			"type": "string"
		},
		"nodes": {
			"type": "array",
			"items": {
				"$ref": "node"
			}
		}
	},
	"required": [
		"meta",
		"nodes"
	],
	"definitions": {
		"node": {
			"$id": "http://localhost:1234/node",
			"description": "node",
			"type": "object",
			"properties": {
				"value": {
					"type": "number"
				},
				"subtree": {
					"$ref": "tree"
				}
			},
			"required": [
				"value"
			]
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test refs with quote, object with numbers is valid

Original schema

{
	"properties": {
		"foo\"bar": {
			"$ref": "#/definitions/foo%22bar"
		}
	},
	"definitions": {
		"foo\"bar": {
			"type": "number"
		}
	}
}

Schema after validating

{
	"properties": {
		"foo\"bar": {
			"$ref": "#/definitions/foo%22bar"
		}
	},
	"definitions": {
		"foo\"bar": {
			"type": "number"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test refs with quote, object with strings is invalid

Original schema

{
	"properties": {
		"foo\"bar": {
			"$ref": "#/definitions/foo%22bar"
		}
	},
	"definitions": {
		"foo\"bar": {
			"type": "number"
		}
	}
}

Schema after validating

{
	"properties": {
		"foo\"bar": {
			"$ref": "#/definitions/foo%22bar"
		}
	},
	"definitions": {
		"foo\"bar": {
			"type": "number"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Location-independent identifier, match

Original schema

{
	"allOf": [
		{
			"$ref": "#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "#foo",
			"type": "integer"
		}
	}
}

Schema after validating

{
	"allOf": [
		{
			"$ref": "#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "#foo",
			"type": "integer"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Location-independent identifier, mismatch

Original schema

{
	"allOf": [
		{
			"$ref": "#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "#foo",
			"type": "integer"
		}
	}
}

Schema after validating

{
	"allOf": [
		{
			"$ref": "#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "#foo",
			"type": "integer"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Location-independent identifier with absolute URI, match

Original schema

{
	"allOf": [
		{
			"$ref": "http://localhost:1234/bar#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "http://localhost:1234/bar#foo",
			"type": "integer"
		}
	}
}

Schema after validating

{
	"allOf": [
		{
			"$ref": "http://localhost:1234/bar#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "http://localhost:1234/bar#foo",
			"type": "integer"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Location-independent identifier with absolute URI, mismatch

Original schema

{
	"allOf": [
		{
			"$ref": "http://localhost:1234/bar#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "http://localhost:1234/bar#foo",
			"type": "integer"
		}
	}
}

Schema after validating

{
	"allOf": [
		{
			"$ref": "http://localhost:1234/bar#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "http://localhost:1234/bar#foo",
			"type": "integer"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Location-independent identifier with base URI change in subschema, match

Original schema

{
	"$id": "http://localhost:1234/root",
	"allOf": [
		{
			"$ref": "http://localhost:1234/nested.json#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "nested.json",
			"definitions": {
				"B": {
					"$id": "#foo",
					"type": "integer"
				}
			}
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/root",
	"allOf": [
		{
			"$ref": "http://localhost:1234/nested.json#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "nested.json",
			"definitions": {
				"B": {
					"$id": "#foo",
					"type": "integer"
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test Location-independent identifier with base URI change in subschema, mismatch

Original schema

{
	"$id": "http://localhost:1234/root",
	"allOf": [
		{
			"$ref": "http://localhost:1234/nested.json#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "nested.json",
			"definitions": {
				"B": {
					"$id": "#foo",
					"type": "integer"
				}
			}
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/root",
	"allOf": [
		{
			"$ref": "http://localhost:1234/nested.json#foo"
		}
	],
	"definitions": {
		"A": {
			"$id": "nested.json",
			"definitions": {
				"B": {
					"$id": "#foo",
					"type": "integer"
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
		}
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test remote ref, remote ref valid

Original schema

{
	"$ref": "http://localhost:1234/integer.json"
}

Schema after validating

{
	"$ref": "http://localhost:1234/integer.json",
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test remote ref, remote ref invalid

Original schema

{
	"$ref": "http://localhost:1234/integer.json"
}

Schema after validating

{
	"$ref": "http://localhost:1234/integer.json",
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test fragment within remote ref, remote fragment valid

Original schema

{
	"$ref": "http://localhost:1234/subSchemas.json#/integer"
}

Schema after validating

{
	"$ref": "http://localhost:1234/subSchemas.json#/integer",
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test fragment within remote ref, remote fragment invalid

Original schema

{
	"$ref": "http://localhost:1234/subSchemas.json#/integer"
}

Schema after validating

{
	"$ref": "http://localhost:1234/subSchemas.json#/integer",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test base URI change, base URI change ref valid

Original schema

{
	"$id": "http://localhost:1234/",
	"items": {
		"$id": "baseUriChange/",
		"items": {
			"$ref": "folderInteger.json"
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/",
	"items": {
		"$id": "baseUriChange/",
		"items": {
			"$ref": "folderInteger.json"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test base URI change, base URI change ref invalid

Original schema

{
	"$id": "http://localhost:1234/",
	"items": {
		"$id": "baseUriChange/",
		"items": {
			"$ref": "folderInteger.json"
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/",
	"items": {
		"$id": "baseUriChange/",
		"items": {
			"$ref": "folderInteger.json"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/baz"
		}
	},
	"definitions": {
		"baz": {
			"$id": "baseUriChangeFolder/",
			"type": "array",
			"items": {
				"$ref": "folderInteger.json"
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/baz"
		}
	},
	"definitions": {
		"baz": {
			"$id": "baseUriChangeFolder/",
			"type": "array",
			"items": {
				"$ref": "folderInteger.json"
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/baz/definitions/bar"
		}
	},
	"definitions": {
		"baz": {
			"$id": "baseUriChangeFolderInSubschema/",
			"definitions": {
				"bar": {
					"type": "array",
					"items": {
						"$ref": "folderInteger.json"
					}
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": "#/definitions/baz/definitions/bar"
		}
	},
	"definitions": {
		"baz": {
			"$id": "baseUriChangeFolderInSubschema/",
			"definitions": {
				"bar": {
					"type": "array",
					"items": {
						"$ref": "folderInteger.json"
					}
				}
			}
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test root ref in remote ref, string is valid

Original schema

{
	"$id": "http://localhost:1234/object",
	"type": "object",
	"properties": {
		"name": {
			"$ref": "name.json#/definitions/orNull"
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/object",
	"type": "object",
	"properties": {
		"name": {
			"$ref": "name.json#/definitions/orNull"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test root ref in remote ref, null is valid

Original schema

{
	"$id": "http://localhost:1234/object",
	"type": "object",
	"properties": {
		"name": {
			"$ref": "name.json#/definitions/orNull"
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/object",
	"type": "object",
	"properties": {
		"name": {
			"$ref": "name.json#/definitions/orNull"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator had a side-effect on (altered the original) schema in the test root ref in remote ref, object is invalid

Original schema

{
	"$id": "http://localhost:1234/object",
	"type": "object",
	"properties": {
		"name": {
			"$ref": "name.json#/definitions/orNull"
		}
	}
}

Schema after validating

{
	"$id": "http://localhost:1234/object",
	"type": "object",
	"properties": {
		"name": {
			"$ref": "name.json#/definitions/orNull"
		}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": {}
	},
	"additionalProperties": true
}

Side-effect on schema

revalidator 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": [],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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",
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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"
	],
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

Side-effect on schema

revalidator 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,
	"additionalProperties": true
}

back to benchmarks