diff --git a/src/tests/schema_validation/v1_6.rs b/src/tests/schema_validation/v1_6.rs index 1085d3ae..1ca894f3 100644 --- a/src/tests/schema_validation/v1_6.rs +++ b/src/tests/schema_validation/v1_6.rs @@ -87,8 +87,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -110,8 +110,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -137,8 +137,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -158,8 +158,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -175,8 +175,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -194,8 +194,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -214,8 +214,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -233,8 +233,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -253,8 +253,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -272,8 +272,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -289,8 +289,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -308,8 +308,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -330,8 +330,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -349,8 +349,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -370,8 +370,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -390,8 +390,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -409,8 +409,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -426,8 +426,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -445,8 +445,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -462,8 +462,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -483,8 +483,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -515,8 +515,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -534,8 +534,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -558,8 +558,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -581,8 +581,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -598,8 +598,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -615,8 +615,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -632,8 +632,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -649,8 +649,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -668,8 +668,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -700,8 +700,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -717,8 +717,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -738,8 +738,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -757,8 +757,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -774,8 +774,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -793,8 +793,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -816,8 +816,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -835,8 +835,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -854,8 +854,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -873,8 +873,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -894,8 +894,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -913,8 +913,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -953,8 +953,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -972,13 +972,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_start_transaction() { @@ -995,13 +995,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_start_transaction_response() { @@ -1019,13 +1019,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_status_notification() { @@ -1044,13 +1044,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_status_notification_response() { @@ -1061,13 +1061,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_stop_transaction() { @@ -1085,8 +1085,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1108,8 +1108,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1128,13 +1128,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_trigger_message_response() { @@ -1147,13 +1147,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_unlock_connector() { @@ -1164,13 +1164,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_unlock_connector_response() { @@ -1183,13 +1183,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_update_firmware() { @@ -1205,13 +1205,13 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } } - assert!(compiled.is_valid(&instance)) + assert!(compiled.is_valid(&instance)); } #[test] fn validate_update_firmware_response() { @@ -1222,8 +1222,8 @@ mod tests { let instance = serde_json::to_value(&test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } diff --git a/src/tests/schema_validation/v2_0_1.rs b/src/tests/schema_validation/v2_0_1.rs index 36ef7cb4..3373b27c 100644 --- a/src/tests/schema_validation/v2_0_1.rs +++ b/src/tests/schema_validation/v2_0_1.rs @@ -328,8 +328,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -369,8 +369,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -398,8 +398,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -424,8 +424,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -441,8 +441,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -465,8 +465,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -485,8 +485,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -509,8 +509,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -532,8 +532,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -556,8 +556,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -573,8 +573,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -597,8 +597,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -623,8 +623,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -647,8 +647,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -664,8 +664,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -688,8 +688,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -708,8 +708,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -726,8 +726,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -743,8 +743,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -769,8 +769,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -789,8 +789,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -805,8 +805,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -840,8 +840,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -862,8 +862,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -882,8 +882,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -905,8 +905,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -928,8 +928,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -950,8 +950,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -969,8 +969,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -985,8 +985,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1005,8 +1005,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1028,8 +1028,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1047,8 +1047,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1069,8 +1069,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1093,8 +1093,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1116,8 +1116,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1143,8 +1143,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1165,8 +1165,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1185,8 +1185,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1219,8 +1219,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1240,8 +1240,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1262,8 +1262,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1280,8 +1280,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1317,8 +1317,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1333,8 +1333,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1349,8 +1349,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1375,8 +1375,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1398,8 +1398,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1431,8 +1431,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1453,8 +1453,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1486,8 +1486,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1508,8 +1508,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1526,8 +1526,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1545,8 +1545,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1577,8 +1577,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1615,8 +1615,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1631,8 +1631,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1649,8 +1649,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1668,8 +1668,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1690,8 +1690,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1709,8 +1709,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1725,8 +1725,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1763,8 +1763,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1779,8 +1779,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1834,8 +1834,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1850,8 +1850,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1872,8 +1872,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1888,8 +1888,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1928,8 +1928,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1944,8 +1944,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -1983,8 +1983,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2005,8 +2005,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2057,8 +2057,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2079,8 +2079,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2124,8 +2124,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2140,8 +2140,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2182,8 +2182,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2198,8 +2198,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2248,8 +2248,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2264,8 +2264,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2286,8 +2286,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2308,8 +2308,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2328,8 +2328,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2344,8 +2344,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2409,8 +2409,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2425,8 +2425,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2504,8 +2504,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2527,8 +2527,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2545,8 +2545,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2567,8 +2567,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2586,8 +2586,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2602,8 +2602,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2639,8 +2639,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2661,8 +2661,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2680,8 +2680,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2702,8 +2702,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2722,8 +2722,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2738,8 +2738,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2788,8 +2788,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2810,8 +2810,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2872,8 +2872,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2894,8 +2894,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2932,8 +2932,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2954,8 +2954,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2972,8 +2972,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -2994,8 +2994,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3010,8 +3010,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3032,8 +3032,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3075,8 +3075,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3097,8 +3097,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3133,8 +3133,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3172,8 +3172,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3205,8 +3205,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3242,8 +3242,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3261,8 +3261,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3283,8 +3283,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3304,8 +3304,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3320,8 +3320,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3384,8 +3384,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3429,8 +3429,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3451,8 +3451,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3473,8 +3473,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3492,8 +3492,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3514,8 +3514,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3532,8 +3532,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3550,8 +3550,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3577,8 +3577,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); } @@ -3599,8 +3599,8 @@ mod tests { let instance = serde_json::to_value(test).unwrap(); let compiled = Validator::new(&schema).expect("A valid schema"); let result = compiled.validate(&instance); - if let Err(errors) = result { - for error in errors { + if result.is_err() { + for error in compiled.iter_errors(&instance) { println!("Validation error: {}", error); println!("Instance path: {}", error.instance_path); }