
#[test]
fn test_content_0_0() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_content_0_1() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_content_0_2() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_content_1_0() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_content_1_1() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_content_1_2() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_content_2_0() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_content_2_1() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_content_2_2() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_content_2_3() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 3).unwrap();
}

#[test]
fn test_content_3_0() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_content_3_1() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_content_3_2() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_content_3_3() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 3).unwrap();
}

#[test]
fn test_content_3_4() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 4).unwrap();
}

#[test]
fn test_content_3_5() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 5).unwrap();
}

#[test]
fn test_content_3_6() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 6).unwrap();
}

#[test]
fn test_content_3_7() {
    let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 7).unwrap();
}

#[test]
fn test_unique_items_0_0() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_unique_items_0_1() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_unique_items_0_2() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_unique_items_0_3() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_unique_items_0_4() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_unique_items_0_5() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_unique_items_0_6() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_unique_items_0_7() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_unique_items_0_8() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
}

#[test]
fn test_unique_items_0_9() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 9).unwrap();
}

#[test]
fn test_unique_items_0_10() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 10).unwrap();
}

#[test]
fn test_unique_items_0_11() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 11).unwrap();
}

#[test]
fn test_unique_items_0_12() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 12).unwrap();
}

#[test]
fn test_unique_items_0_13() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 13).unwrap();
}

#[test]
fn test_unique_items_0_14() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 14).unwrap();
}

#[test]
fn test_unique_items_0_15() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 15).unwrap();
}

#[test]
fn test_unique_items_0_16() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 16).unwrap();
}

#[test]
fn test_unique_items_0_17() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 17).unwrap();
}

#[test]
fn test_unique_items_0_18() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 18).unwrap();
}

#[test]
fn test_unique_items_0_19() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 19).unwrap();
}

#[test]
fn test_unique_items_0_20() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 20).unwrap();
}

#[test]
fn test_unique_items_0_21() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 21).unwrap();
}

#[test]
fn test_unique_items_0_22() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 22).unwrap();
}

#[test]
fn test_unique_items_0_23() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 23).unwrap();
}

#[test]
fn test_unique_items_0_24() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 24).unwrap();
}

#[test]
fn test_unique_items_0_25() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 25).unwrap();
}

#[test]
fn test_unique_items_0_26() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 26).unwrap();
}

#[test]
fn test_unique_items_0_27() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 27).unwrap();
}

#[test]
fn test_unique_items_1_0() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_unique_items_1_1() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_unique_items_1_2() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_unique_items_1_3() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_unique_items_1_4() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_unique_items_1_5() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 5).unwrap();
}

#[test]
fn test_unique_items_1_6() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 6).unwrap();
}

#[test]
fn test_unique_items_1_7() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 7).unwrap();
}

#[test]
fn test_unique_items_2_0() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_unique_items_2_1() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_unique_items_2_2() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_unique_items_2_3() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 3).unwrap();
}

#[test]
fn test_unique_items_2_4() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 4).unwrap();
}

#[test]
fn test_unique_items_3_0() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_unique_items_3_1() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_unique_items_3_2() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_unique_items_3_3() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 3).unwrap();
}

#[test]
fn test_unique_items_3_4() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 4).unwrap();
}

#[test]
fn test_unique_items_3_5() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 5).unwrap();
}

#[test]
fn test_unique_items_3_6() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 6).unwrap();
}

#[test]
fn test_unique_items_3_7() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 7).unwrap();
}

#[test]
fn test_unique_items_3_8() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 8).unwrap();
}

#[test]
fn test_unique_items_3_9() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 9).unwrap();
}

#[test]
fn test_unique_items_3_10() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 10).unwrap();
}

#[test]
fn test_unique_items_3_11() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 11).unwrap();
}

#[test]
fn test_unique_items_3_12() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 12).unwrap();
}

#[test]
fn test_unique_items_3_13() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 13).unwrap();
}

#[test]
fn test_unique_items_3_14() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 14).unwrap();
}

#[test]
fn test_unique_items_4_0() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_unique_items_4_1() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_unique_items_4_2() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_unique_items_4_3() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_unique_items_4_4() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 4).unwrap();
}

#[test]
fn test_unique_items_4_5() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 5).unwrap();
}

#[test]
fn test_unique_items_4_6() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 6).unwrap();
}

#[test]
fn test_unique_items_4_7() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 7).unwrap();
}

#[test]
fn test_unique_items_5_0() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_unique_items_5_1() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_unique_items_5_2() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_unique_items_5_3() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_unique_items_5_4() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 4).unwrap();
}

#[test]
fn test_unique_items_6_0() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_unique_items_6_1() {
    let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_min_items_0_0() {
    let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_min_items_0_1() {
    let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_min_items_0_2() {
    let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_min_items_0_3() {
    let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_min_items_1_0() {
    let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_min_items_1_1() {
    let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_min_items_2_0() {
    let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_additional_properties_0_0() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_additional_properties_0_1() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_additional_properties_0_2() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_additional_properties_1_0() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_additional_properties_1_1() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_additional_properties_2_0() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_additional_properties_2_1() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_additional_properties_2_2() {
    let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_dependencies_0_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_dependencies_0_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_dependencies_0_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_dependencies_0_3() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_dependencies_0_4() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_dependencies_0_5() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_dependencies_0_6() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_dependencies_1_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_dependencies_1_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_dependencies_1_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_dependencies_2_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_dependencies_2_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_dependencies_2_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_dependencies_2_3() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 3).unwrap();
}

#[test]
fn test_dependencies_2_4() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 4).unwrap();
}

#[test]
fn test_dependencies_2_5() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 5).unwrap();
}

#[test]
fn test_dependencies_3_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_dependencies_3_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_dependencies_3_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_dependencies_3_3() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 3).unwrap();
}

#[test]
fn test_dependencies_4_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_dependencies_5_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_dependencies_5_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_dependencies_5_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_dependencies_5_3() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_dependencies_5_4() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 4).unwrap();
}

#[test]
fn test_dependencies_5_5() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 5).unwrap();
}

#[test]
fn test_dependencies_5_6() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 6).unwrap();
}

#[test]
fn test_dependencies_5_7() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 7).unwrap();
}

#[test]
fn test_dependencies_6_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_dependencies_7_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_dependencies_7_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_dependencies_7_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 2).unwrap();
}

#[test]
fn test_dependencies_7_3() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 3).unwrap();
}

#[test]
fn test_dependencies_8_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_dependencies_8_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_dependencies_8_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 2).unwrap();
}

#[test]
fn test_dependencies_8_3() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 3).unwrap();
}

#[test]
fn test_dependencies_9_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_dependencies_9_1() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_dependencies_9_2() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_dependencies_9_3() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 3).unwrap();
}

#[test]
fn test_dependencies_10_0() {
    let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_exclusive_minimum_0_0() {
    let path = format!("{}/fixtures/exclusiveMinimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_exclusive_minimum_0_1() {
    let path = format!("{}/fixtures/exclusiveMinimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_exclusive_minimum_0_2() {
    let path = format!("{}/fixtures/exclusiveMinimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_exclusive_minimum_0_3() {
    let path = format!("{}/fixtures/exclusiveMinimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_const_0_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_const_0_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_const_0_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_const_1_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_const_1_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_const_1_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_const_1_3() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_const_2_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_const_2_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_const_2_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_const_3_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_const_3_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_const_4_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_const_4_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_const_4_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_const_5_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_const_5_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_const_5_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_const_6_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_const_6_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_const_6_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 2).unwrap();
}

#[test]
fn test_const_7_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_const_7_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_const_7_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 2).unwrap();
}

#[test]
fn test_const_8_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_const_8_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_const_8_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 2).unwrap();
}

#[test]
fn test_const_9_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_const_9_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_const_9_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_const_10_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_const_10_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 1).unwrap();
}

#[test]
fn test_const_10_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 2).unwrap();
}

#[test]
fn test_const_10_3() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 3).unwrap();
}

#[test]
fn test_const_10_4() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 4).unwrap();
}

#[test]
fn test_const_10_5() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 5).unwrap();
}

#[test]
fn test_const_11_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_const_11_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_const_11_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 2).unwrap();
}

#[test]
fn test_const_12_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_const_12_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 1).unwrap();
}

#[test]
fn test_const_12_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 2).unwrap();
}

#[test]
fn test_const_12_3() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 3).unwrap();
}

#[test]
fn test_const_12_4() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 4).unwrap();
}

#[test]
fn test_const_13_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
}

#[test]
fn test_const_13_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
}

#[test]
fn test_const_13_2() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 2).unwrap();
}

#[test]
fn test_const_13_3() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 3).unwrap();
}

#[test]
fn test_const_14_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 0).unwrap();
}

#[test]
fn test_const_14_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 1).unwrap();
}

#[test]
fn test_const_15_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 0).unwrap();
}

#[test]
fn test_const_15_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 1).unwrap();
}

#[test]
fn test_const_16_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 0).unwrap();
}

#[test]
fn test_const_16_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 1).unwrap();
}

#[test]
fn test_const_17_0() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 0).unwrap();
}

#[test]
fn test_const_17_1() {
    let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 1).unwrap();
}

#[test]
fn test_families_0_0() {
    let path = format!("{}/fixtures/families.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_families_0_1() {
    let path = format!("{}/fixtures/families.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_families_0_2() {
    let path = format!("{}/fixtures/families.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_families_0_3() {
    let path = format!("{}/fixtures/families.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_families_0_4() {
    let path = format!("{}/fixtures/families.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_families_1_0() {
    let path = format!("{}/fixtures/families.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_property_names_0_0() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_property_names_0_1() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_property_names_0_2() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_property_names_0_3() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_property_names_0_4() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_property_names_0_5() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_property_names_1_0() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_property_names_1_1() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_property_names_1_2() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_property_names_2_0() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_property_names_2_1() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_property_names_3_0() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_property_names_3_1() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_property_names_4_0() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_property_names_4_1() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_property_names_4_2() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_property_names_5_0() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_property_names_5_1() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_property_names_5_2() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_property_names_5_3() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_property_names_6_0() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_property_names_6_1() {
    let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_queryer_0_0() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_queryer_0_1() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_queryer_0_2() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_queryer_0_3() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_queryer_0_4() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_queryer_0_5() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_queryer_0_6() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_queryer_0_7() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_queryer_0_8() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
}

#[test]
fn test_queryer_0_9() {
    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 9).unwrap();
}

#[test]
fn test_not_0_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_not_0_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_not_1_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_not_1_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_not_1_2() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_not_2_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_not_2_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_not_2_2() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_not_3_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_not_3_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_not_4_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_not_4_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_not_4_2() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_not_4_3() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_not_4_4() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 4).unwrap();
}

#[test]
fn test_not_4_5() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 5).unwrap();
}

#[test]
fn test_not_4_6() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 6).unwrap();
}

#[test]
fn test_not_4_7() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 7).unwrap();
}

#[test]
fn test_not_4_8() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 8).unwrap();
}

#[test]
fn test_not_5_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_not_5_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_not_5_2() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_not_5_3() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_not_5_4() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 4).unwrap();
}

#[test]
fn test_not_5_5() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 5).unwrap();
}

#[test]
fn test_not_5_6() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 6).unwrap();
}

#[test]
fn test_not_5_7() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 7).unwrap();
}

#[test]
fn test_not_5_8() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 8).unwrap();
}

#[test]
fn test_not_6_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_not_6_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_not_6_2() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 2).unwrap();
}

#[test]
fn test_not_6_3() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 3).unwrap();
}

#[test]
fn test_not_6_4() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 4).unwrap();
}

#[test]
fn test_not_6_5() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 5).unwrap();
}

#[test]
fn test_not_6_6() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 6).unwrap();
}

#[test]
fn test_not_6_7() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 7).unwrap();
}

#[test]
fn test_not_6_8() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 8).unwrap();
}

#[test]
fn test_not_7_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_not_8_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_not_9_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_not_10_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_not_11_0() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_not_11_1() {
    let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_items_0_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_items_0_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_items_0_2() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_items_0_3() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_items_1_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_items_1_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_items_2_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_items_2_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_items_3_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_items_3_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_items_3_2() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_items_3_3() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 3).unwrap();
}

#[test]
fn test_items_3_4() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 4).unwrap();
}

#[test]
fn test_items_3_5() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 5).unwrap();
}

#[test]
fn test_items_4_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_items_4_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_items_4_2() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_items_5_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_items_5_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_items_5_2() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_items_5_3() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_items_5_4() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 4).unwrap();
}

#[test]
fn test_items_6_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_items_6_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_items_7_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_items_7_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_items_8_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_items_8_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_items_9_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_items_10_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_items_11_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_items_11_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_items_12_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_items_12_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 1).unwrap();
}

#[test]
fn test_items_13_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
}

#[test]
fn test_items_13_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
}

#[test]
fn test_items_14_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 0).unwrap();
}

#[test]
fn test_items_14_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 1).unwrap();
}

#[test]
fn test_items_15_0() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 0).unwrap();
}

#[test]
fn test_items_15_1() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 1).unwrap();
}

#[test]
fn test_items_15_2() {
    let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 2).unwrap();
}

#[test]
fn test_enum_0_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_enum_0_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_enum_1_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_enum_1_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_enum_1_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_enum_1_3() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_enum_1_4() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_enum_2_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_enum_2_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_enum_2_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_enum_3_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_enum_3_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_enum_3_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_enum_3_3() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 3).unwrap();
}

#[test]
fn test_enum_3_4() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 4).unwrap();
}

#[test]
fn test_enum_3_5() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 5).unwrap();
}

#[test]
fn test_enum_4_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_enum_4_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_enum_4_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_enum_5_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_enum_5_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_enum_5_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_enum_6_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_enum_6_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_enum_6_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 2).unwrap();
}

#[test]
fn test_enum_7_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_enum_7_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_enum_7_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 2).unwrap();
}

#[test]
fn test_enum_8_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_enum_8_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_enum_8_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 2).unwrap();
}

#[test]
fn test_enum_9_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_enum_9_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_enum_9_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_enum_10_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_enum_10_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 1).unwrap();
}

#[test]
fn test_enum_10_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 2).unwrap();
}

#[test]
fn test_enum_11_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_enum_11_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_enum_11_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 2).unwrap();
}

#[test]
fn test_enum_12_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_enum_12_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 1).unwrap();
}

#[test]
fn test_enum_12_2() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 2).unwrap();
}

#[test]
fn test_enum_13_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
}

#[test]
fn test_enum_13_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
}

#[test]
fn test_enum_14_0() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 0).unwrap();
}

#[test]
fn test_enum_14_1() {
    let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 1).unwrap();
}

#[test]
fn test_min_properties_0_0() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_min_properties_0_1() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_min_properties_0_2() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_min_properties_0_3() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_min_properties_0_4() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_min_properties_0_5() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_min_properties_1_0() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_min_properties_1_1() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_min_properties_2_0() {
    let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_min_contains_0_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_min_contains_0_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_min_contains_1_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_min_contains_1_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_min_contains_1_2() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_min_contains_1_3() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_min_contains_1_4() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_min_contains_2_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_min_contains_2_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_min_contains_2_2() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_min_contains_2_3() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 3).unwrap();
}

#[test]
fn test_min_contains_2_4() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 4).unwrap();
}

#[test]
fn test_min_contains_2_5() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 5).unwrap();
}

#[test]
fn test_min_contains_3_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_min_contains_3_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_min_contains_4_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_min_contains_4_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_min_contains_4_2() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_min_contains_4_3() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_min_contains_5_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_min_contains_5_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_min_contains_5_2() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_min_contains_5_3() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_min_contains_6_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_min_contains_6_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_min_contains_7_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_min_contains_7_1() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_min_contains_7_2() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 2).unwrap();
}

#[test]
fn test_min_contains_8_0() {
    let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_properties_0_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_properties_0_1() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_properties_0_2() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_properties_0_3() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_properties_0_4() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_properties_0_5() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_properties_1_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_properties_1_1() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_properties_1_2() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_properties_1_3() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_properties_2_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_properties_2_1() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_properties_3_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_properties_4_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_properties_4_1() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_properties_4_2() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_properties_4_3() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_properties_4_4() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 4).unwrap();
}

#[test]
fn test_properties_4_5() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 5).unwrap();
}

#[test]
fn test_properties_4_6() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 6).unwrap();
}

#[test]
fn test_properties_5_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_properties_6_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_properties_7_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_properties_8_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_properties_9_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_properties_10_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_properties_11_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_properties_12_0() {
    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_max_contains_0_0() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_max_contains_0_1() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_max_contains_1_0() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_max_contains_1_1() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_max_contains_1_2() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_max_contains_1_3() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_max_contains_1_4() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_max_contains_2_0() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_max_contains_2_1() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_max_contains_3_0() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_max_contains_3_1() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_max_contains_3_2() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_max_contains_4_0() {
    let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_max_length_0_0() {
    let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_max_length_0_1() {
    let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_max_length_0_2() {
    let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_max_length_0_3() {
    let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_max_length_0_4() {
    let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_max_length_1_0() {
    let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_max_length_1_1() {
    let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_exclusive_maximum_0_0() {
    let path = format!("{}/fixtures/exclusiveMaximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_exclusive_maximum_0_1() {
    let path = format!("{}/fixtures/exclusiveMaximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_exclusive_maximum_0_2() {
    let path = format!("{}/fixtures/exclusiveMaximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_exclusive_maximum_0_3() {
    let path = format!("{}/fixtures/exclusiveMaximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_prefix_items_0_0() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_prefix_items_0_1() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_prefix_items_0_2() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_prefix_items_0_3() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_prefix_items_0_4() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_prefix_items_0_5() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_prefix_items_1_0() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_prefix_items_1_1() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_prefix_items_1_2() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_prefix_items_2_0() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_prefix_items_3_0() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_prefix_items_4_0() {
    let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_minimum_0_0() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_minimum_0_1() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_minimum_0_2() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_minimum_0_3() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_minimum_1_0() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_minimum_1_1() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_minimum_1_2() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_minimum_1_3() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_minimum_1_4() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_minimum_1_5() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 5).unwrap();
}

#[test]
fn test_minimum_1_6() {
    let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 6).unwrap();
}

#[test]
fn test_one_of_0_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_one_of_0_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_one_of_0_2() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_one_of_0_3() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_one_of_1_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_one_of_1_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_one_of_1_2() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_one_of_2_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_one_of_3_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_one_of_4_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_one_of_5_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_one_of_6_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_one_of_6_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_one_of_6_2() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 2).unwrap();
}

#[test]
fn test_one_of_6_3() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 3).unwrap();
}

#[test]
fn test_one_of_7_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_one_of_7_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_one_of_8_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_one_of_8_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_one_of_8_2() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 2).unwrap();
}

#[test]
fn test_one_of_8_3() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 3).unwrap();
}

#[test]
fn test_one_of_8_4() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 4).unwrap();
}

#[test]
fn test_one_of_9_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_one_of_9_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_one_of_9_2() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_one_of_9_3() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 3).unwrap();
}

#[test]
fn test_one_of_9_4() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 4).unwrap();
}

#[test]
fn test_one_of_10_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_one_of_10_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 1).unwrap();
}

#[test]
fn test_one_of_10_2() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 2).unwrap();
}

#[test]
fn test_one_of_10_3() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 3).unwrap();
}

#[test]
fn test_one_of_11_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_one_of_11_1() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_one_of_12_0() {
    let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_boolean_schema_0_0() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_boolean_schema_0_1() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_boolean_schema_0_2() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_boolean_schema_0_3() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_boolean_schema_0_4() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_boolean_schema_0_5() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_boolean_schema_0_6() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_boolean_schema_0_7() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_boolean_schema_0_8() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
}

#[test]
fn test_boolean_schema_1_0() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_boolean_schema_1_1() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_boolean_schema_1_2() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_boolean_schema_1_3() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_boolean_schema_1_4() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_boolean_schema_1_5() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 5).unwrap();
}

#[test]
fn test_boolean_schema_1_6() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 6).unwrap();
}

#[test]
fn test_boolean_schema_1_7() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 7).unwrap();
}

#[test]
fn test_boolean_schema_1_8() {
    let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 8).unwrap();
}

#[test]
fn test_if_then_else_0_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_if_then_else_0_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_if_then_else_1_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_if_then_else_1_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_if_then_else_2_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_if_then_else_2_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_if_then_else_3_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_if_then_else_3_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_if_then_else_3_2() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_if_then_else_4_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_if_then_else_4_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_if_then_else_4_2() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_if_then_else_5_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_if_then_else_5_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_if_then_else_5_2() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_if_then_else_5_3() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_if_then_else_6_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_if_then_else_6_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_if_then_else_7_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_if_then_else_7_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_if_then_else_8_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_if_then_else_8_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_if_then_else_9_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_if_then_else_9_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_if_then_else_9_2() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_if_then_else_9_3() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 3).unwrap();
}

#[test]
fn test_if_then_else_10_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_if_then_else_10_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 1).unwrap();
}

#[test]
fn test_if_then_else_11_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_if_then_else_11_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_if_then_else_12_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_if_then_else_13_0() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
}

#[test]
fn test_if_then_else_13_1() {
    let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
}

#[test]
fn test_empty_string_0_0() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_empty_string_0_1() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_empty_string_0_2() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_empty_string_0_3() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_empty_string_0_4() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_empty_string_0_5() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_empty_string_0_6() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_empty_string_0_7() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_empty_string_0_8() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
}

#[test]
fn test_empty_string_0_9() {
    let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 9).unwrap();
}

#[test]
fn test_pattern_0_0() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_pattern_0_1() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_pattern_0_2() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_pattern_0_3() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_pattern_0_4() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_pattern_0_5() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_pattern_0_6() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_pattern_0_7() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_pattern_1_0() {
    let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_max_properties_0_0() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_max_properties_0_1() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_max_properties_0_2() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_max_properties_0_3() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_max_properties_0_4() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_max_properties_0_5() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_max_properties_1_0() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_max_properties_1_1() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_max_properties_2_0() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_max_properties_2_1() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_max_properties_3_0() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_max_properties_3_1() {
    let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_required_0_0() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_required_0_1() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_required_0_2() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_required_0_3() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_required_0_4() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_required_0_5() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_required_0_6() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_required_1_0() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_required_2_0() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_required_3_0() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_required_3_1() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_required_4_0() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_required_4_1() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_required_4_2() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_required_4_3() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_required_4_4() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 4).unwrap();
}

#[test]
fn test_required_4_5() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 5).unwrap();
}

#[test]
fn test_required_4_6() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 6).unwrap();
}

#[test]
fn test_required_5_0() {
    let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_type_0_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_type_0_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_type_0_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_type_0_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_type_0_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_type_0_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_type_0_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_type_0_7() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_type_0_8() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
}

#[test]
fn test_type_1_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_type_1_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_type_1_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_type_1_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_type_1_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_type_1_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 5).unwrap();
}

#[test]
fn test_type_1_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 6).unwrap();
}

#[test]
fn test_type_1_7() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 7).unwrap();
}

#[test]
fn test_type_1_8() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 8).unwrap();
}

#[test]
fn test_type_2_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_type_2_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_type_2_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_type_2_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 3).unwrap();
}

#[test]
fn test_type_2_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 4).unwrap();
}

#[test]
fn test_type_2_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 5).unwrap();
}

#[test]
fn test_type_2_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 6).unwrap();
}

#[test]
fn test_type_2_7() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 7).unwrap();
}

#[test]
fn test_type_2_8() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 8).unwrap();
}

#[test]
fn test_type_3_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_type_3_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_type_3_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_type_3_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 3).unwrap();
}

#[test]
fn test_type_3_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 4).unwrap();
}

#[test]
fn test_type_3_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 5).unwrap();
}

#[test]
fn test_type_3_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 6).unwrap();
}

#[test]
fn test_type_4_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_type_4_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_type_4_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_type_4_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_type_4_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 4).unwrap();
}

#[test]
fn test_type_4_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 5).unwrap();
}

#[test]
fn test_type_4_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 6).unwrap();
}

#[test]
fn test_type_5_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_type_5_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_type_5_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_type_5_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_type_5_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 4).unwrap();
}

#[test]
fn test_type_5_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 5).unwrap();
}

#[test]
fn test_type_5_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 6).unwrap();
}

#[test]
fn test_type_5_7() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 7).unwrap();
}

#[test]
fn test_type_5_8() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 8).unwrap();
}

#[test]
fn test_type_5_9() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 9).unwrap();
}

#[test]
fn test_type_6_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_type_6_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_type_6_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 2).unwrap();
}

#[test]
fn test_type_6_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 3).unwrap();
}

#[test]
fn test_type_6_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 4).unwrap();
}

#[test]
fn test_type_6_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 5).unwrap();
}

#[test]
fn test_type_6_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 6).unwrap();
}

#[test]
fn test_type_6_7() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 7).unwrap();
}

#[test]
fn test_type_6_8() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 8).unwrap();
}

#[test]
fn test_type_6_9() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 9).unwrap();
}

#[test]
fn test_type_7_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_type_7_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_type_7_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 2).unwrap();
}

#[test]
fn test_type_7_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 3).unwrap();
}

#[test]
fn test_type_7_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 4).unwrap();
}

#[test]
fn test_type_7_5() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 5).unwrap();
}

#[test]
fn test_type_7_6() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 6).unwrap();
}

#[test]
fn test_type_8_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_type_8_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_type_9_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_type_9_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_type_9_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_type_9_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 3).unwrap();
}

#[test]
fn test_type_9_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 4).unwrap();
}

#[test]
fn test_type_10_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_type_10_1() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 1).unwrap();
}

#[test]
fn test_type_10_2() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 2).unwrap();
}

#[test]
fn test_type_10_3() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 3).unwrap();
}

#[test]
fn test_type_10_4() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 4).unwrap();
}

#[test]
fn test_type_11_0() {
    let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_multiple_of_0_0() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_multiple_of_0_1() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_multiple_of_0_2() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_multiple_of_1_0() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_multiple_of_1_1() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_multiple_of_1_2() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_multiple_of_2_0() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_multiple_of_2_1() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_multiple_of_3_0() {
    let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_pattern_properties_0_0() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_pattern_properties_0_1() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_pattern_properties_0_2() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_pattern_properties_0_3() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_pattern_properties_0_4() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_pattern_properties_0_5() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_pattern_properties_0_6() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_pattern_properties_0_7() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_pattern_properties_1_0() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_pattern_properties_1_1() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_pattern_properties_1_2() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_pattern_properties_1_3() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_pattern_properties_1_4() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_pattern_properties_1_5() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 5).unwrap();
}

#[test]
fn test_pattern_properties_2_0() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_pattern_properties_2_1() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_pattern_properties_2_2() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_pattern_properties_2_3() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 3).unwrap();
}

#[test]
fn test_pattern_properties_3_0() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_pattern_properties_3_1() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_pattern_properties_3_2() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_pattern_properties_3_3() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 3).unwrap();
}

#[test]
fn test_pattern_properties_3_4() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 4).unwrap();
}

#[test]
fn test_pattern_properties_4_0() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_pattern_properties_5_0() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_pattern_properties_5_1() {
    let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_merge_0_0() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_merge_0_1() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_merge_1_0() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_merge_1_1() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_merge_1_2() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_merge_2_0() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_merge_2_1() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_merge_2_2() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_merge_3_0() {
    let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_all_of_0_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_all_of_0_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_all_of_0_2() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_all_of_0_3() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_all_of_1_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_all_of_1_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_all_of_1_2() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_all_of_1_3() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_all_of_1_4() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_all_of_2_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_all_of_2_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_all_of_3_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_all_of_4_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_all_of_5_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_all_of_6_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_all_of_7_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_all_of_8_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_all_of_8_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_all_of_9_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_all_of_9_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_all_of_10_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_all_of_10_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 1).unwrap();
}

#[test]
fn test_all_of_11_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_all_of_12_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_all_of_12_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 1).unwrap();
}

#[test]
fn test_all_of_13_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
}

#[test]
fn test_all_of_14_0() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 0).unwrap();
}

#[test]
fn test_all_of_14_1() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 1).unwrap();
}

#[test]
fn test_all_of_14_2() {
    let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 2).unwrap();
}

#[test]
fn test_format_0_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_format_0_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_format_0_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_format_0_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_format_0_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_format_0_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_format_0_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}

#[test]
fn test_format_0_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}

#[test]
fn test_format_0_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
}

#[test]
fn test_format_0_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 9).unwrap();
}

#[test]
fn test_format_0_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 10).unwrap();
}

#[test]
fn test_format_0_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 11).unwrap();
}

#[test]
fn test_format_0_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 12).unwrap();
}

#[test]
fn test_format_0_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 13).unwrap();
}

#[test]
fn test_format_0_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 14).unwrap();
}

#[test]
fn test_format_0_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 15).unwrap();
}

#[test]
fn test_format_0_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 16).unwrap();
}

#[test]
fn test_format_0_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 17).unwrap();
}

#[test]
fn test_format_0_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 18).unwrap();
}

#[test]
fn test_format_0_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 19).unwrap();
}

#[test]
fn test_format_0_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 20).unwrap();
}

#[test]
fn test_format_0_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 21).unwrap();
}

#[test]
fn test_format_0_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 22).unwrap();
}

#[test]
fn test_format_0_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 23).unwrap();
}

#[test]
fn test_format_0_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 24).unwrap();
}

#[test]
fn test_format_0_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 25).unwrap();
}

#[test]
fn test_format_1_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_format_1_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_format_1_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_format_1_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_format_1_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 4).unwrap();
}

#[test]
fn test_format_1_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 5).unwrap();
}

#[test]
fn test_format_1_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 6).unwrap();
}

#[test]
fn test_format_1_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 7).unwrap();
}

#[test]
fn test_format_1_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 8).unwrap();
}

#[test]
fn test_format_1_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 9).unwrap();
}

#[test]
fn test_format_1_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 10).unwrap();
}

#[test]
fn test_format_1_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 11).unwrap();
}

#[test]
fn test_format_1_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 12).unwrap();
}

#[test]
fn test_format_1_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 13).unwrap();
}

#[test]
fn test_format_1_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 14).unwrap();
}

#[test]
fn test_format_1_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 15).unwrap();
}

#[test]
fn test_format_1_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 16).unwrap();
}

#[test]
fn test_format_1_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 17).unwrap();
}

#[test]
fn test_format_1_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 18).unwrap();
}

#[test]
fn test_format_1_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 19).unwrap();
}

#[test]
fn test_format_1_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 20).unwrap();
}

#[test]
fn test_format_1_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 21).unwrap();
}

#[test]
fn test_format_1_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 22).unwrap();
}

#[test]
fn test_format_1_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 23).unwrap();
}

#[test]
fn test_format_1_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 24).unwrap();
}

#[test]
fn test_format_1_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 25).unwrap();
}

#[test]
fn test_format_1_26() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 26).unwrap();
}

#[test]
fn test_format_1_27() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 27).unwrap();
}

#[test]
fn test_format_1_28() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 28).unwrap();
}

#[test]
fn test_format_1_29() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 29).unwrap();
}

#[test]
fn test_format_1_30() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 30).unwrap();
}

#[test]
fn test_format_1_31() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 31).unwrap();
}

#[test]
fn test_format_1_32() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 32).unwrap();
}

#[test]
fn test_format_1_33() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 33).unwrap();
}

#[test]
fn test_format_1_34() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 34).unwrap();
}

#[test]
fn test_format_1_35() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 35).unwrap();
}

#[test]
fn test_format_1_36() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 36).unwrap();
}

#[test]
fn test_format_1_37() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 37).unwrap();
}

#[test]
fn test_format_1_38() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 38).unwrap();
}

#[test]
fn test_format_1_39() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 39).unwrap();
}

#[test]
fn test_format_1_40() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 40).unwrap();
}

#[test]
fn test_format_1_41() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 41).unwrap();
}

#[test]
fn test_format_1_42() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 42).unwrap();
}

#[test]
fn test_format_1_43() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 43).unwrap();
}

#[test]
fn test_format_1_44() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 44).unwrap();
}

#[test]
fn test_format_1_45() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 45).unwrap();
}

#[test]
fn test_format_1_46() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 46).unwrap();
}

#[test]
fn test_format_1_47() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 47).unwrap();
}

#[test]
fn test_format_2_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_format_2_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_format_2_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 2).unwrap();
}

#[test]
fn test_format_2_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 3).unwrap();
}

#[test]
fn test_format_2_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 4).unwrap();
}

#[test]
fn test_format_2_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 5).unwrap();
}

#[test]
fn test_format_2_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 6).unwrap();
}

#[test]
fn test_format_2_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 7).unwrap();
}

#[test]
fn test_format_2_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 8).unwrap();
}

#[test]
fn test_format_2_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 9).unwrap();
}

#[test]
fn test_format_2_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 10).unwrap();
}

#[test]
fn test_format_2_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 11).unwrap();
}

#[test]
fn test_format_2_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 12).unwrap();
}

#[test]
fn test_format_2_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 13).unwrap();
}

#[test]
fn test_format_2_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 14).unwrap();
}

#[test]
fn test_format_2_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 15).unwrap();
}

#[test]
fn test_format_2_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 16).unwrap();
}

#[test]
fn test_format_2_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 17).unwrap();
}

#[test]
fn test_format_2_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 18).unwrap();
}

#[test]
fn test_format_2_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 19).unwrap();
}

#[test]
fn test_format_2_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 20).unwrap();
}

#[test]
fn test_format_2_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 21).unwrap();
}

#[test]
fn test_format_2_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 22).unwrap();
}

#[test]
fn test_format_2_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 23).unwrap();
}

#[test]
fn test_format_2_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 24).unwrap();
}

#[test]
fn test_format_2_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 25).unwrap();
}

#[test]
fn test_format_3_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_format_4_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_format_4_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_format_4_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_format_4_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_format_4_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 4).unwrap();
}

#[test]
fn test_format_4_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 5).unwrap();
}

#[test]
fn test_format_4_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 6).unwrap();
}

#[test]
fn test_format_4_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 7).unwrap();
}

#[test]
fn test_format_4_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 8).unwrap();
}

#[test]
fn test_format_4_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 9).unwrap();
}

#[test]
fn test_format_4_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 10).unwrap();
}

#[test]
fn test_format_4_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 11).unwrap();
}

#[test]
fn test_format_4_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 12).unwrap();
}

#[test]
fn test_format_4_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 13).unwrap();
}

#[test]
fn test_format_4_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 14).unwrap();
}

#[test]
fn test_format_4_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 15).unwrap();
}

#[test]
fn test_format_4_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 16).unwrap();
}

#[test]
fn test_format_4_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 17).unwrap();
}

#[test]
fn test_format_4_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 18).unwrap();
}

#[test]
fn test_format_4_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 19).unwrap();
}

#[test]
fn test_format_4_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 20).unwrap();
}

#[test]
fn test_format_4_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 21).unwrap();
}

#[test]
fn test_format_4_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 22).unwrap();
}

#[test]
fn test_format_4_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 23).unwrap();
}

#[test]
fn test_format_5_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_format_5_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_format_5_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
}

#[test]
fn test_format_5_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 3).unwrap();
}

#[test]
fn test_format_5_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 4).unwrap();
}

#[test]
fn test_format_5_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 5).unwrap();
}

#[test]
fn test_format_5_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 6).unwrap();
}

#[test]
fn test_format_5_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 7).unwrap();
}

#[test]
fn test_format_5_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 8).unwrap();
}

#[test]
fn test_format_5_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 9).unwrap();
}

#[test]
fn test_format_5_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 10).unwrap();
}

#[test]
fn test_format_5_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 11).unwrap();
}

#[test]
fn test_format_5_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 12).unwrap();
}

#[test]
fn test_format_5_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 13).unwrap();
}

#[test]
fn test_format_5_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 14).unwrap();
}

#[test]
fn test_format_5_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 15).unwrap();
}

#[test]
fn test_format_5_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 16).unwrap();
}

#[test]
fn test_format_5_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 17).unwrap();
}

#[test]
fn test_format_5_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 18).unwrap();
}

#[test]
fn test_format_5_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 19).unwrap();
}

#[test]
fn test_format_5_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 20).unwrap();
}

#[test]
fn test_format_5_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 21).unwrap();
}

#[test]
fn test_format_5_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 22).unwrap();
}

#[test]
fn test_format_5_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 23).unwrap();
}

#[test]
fn test_format_6_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_format_6_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_format_6_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 2).unwrap();
}

#[test]
fn test_format_6_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 3).unwrap();
}

#[test]
fn test_format_6_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 4).unwrap();
}

#[test]
fn test_format_6_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 5).unwrap();
}

#[test]
fn test_format_6_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 6).unwrap();
}

#[test]
fn test_format_6_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 7).unwrap();
}

#[test]
fn test_format_6_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 8).unwrap();
}

#[test]
fn test_format_6_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 9).unwrap();
}

#[test]
fn test_format_6_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 10).unwrap();
}

#[test]
fn test_format_6_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 11).unwrap();
}

#[test]
fn test_format_6_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 12).unwrap();
}

#[test]
fn test_format_6_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 13).unwrap();
}

#[test]
fn test_format_6_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 14).unwrap();
}

#[test]
fn test_format_6_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 15).unwrap();
}

#[test]
fn test_format_6_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 16).unwrap();
}

#[test]
fn test_format_6_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 17).unwrap();
}

#[test]
fn test_format_6_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 18).unwrap();
}

#[test]
fn test_format_6_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 19).unwrap();
}

#[test]
fn test_format_6_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 20).unwrap();
}

#[test]
fn test_format_6_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 21).unwrap();
}

#[test]
fn test_format_6_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 22).unwrap();
}

#[test]
fn test_format_6_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 23).unwrap();
}

#[test]
fn test_format_6_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 24).unwrap();
}

#[test]
fn test_format_6_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 25).unwrap();
}

#[test]
fn test_format_6_26() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 26).unwrap();
}

#[test]
fn test_format_6_27() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 27).unwrap();
}

#[test]
fn test_format_6_28() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 28).unwrap();
}

#[test]
fn test_format_6_29() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 29).unwrap();
}

#[test]
fn test_format_6_30() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 30).unwrap();
}

#[test]
fn test_format_6_31() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 31).unwrap();
}

#[test]
fn test_format_6_32() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 32).unwrap();
}

#[test]
fn test_format_6_33() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 33).unwrap();
}

#[test]
fn test_format_6_34() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 34).unwrap();
}

#[test]
fn test_format_6_35() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 35).unwrap();
}

#[test]
fn test_format_6_36() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 36).unwrap();
}

#[test]
fn test_format_7_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_format_7_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 1).unwrap();
}

#[test]
fn test_format_7_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 2).unwrap();
}

#[test]
fn test_format_7_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 3).unwrap();
}

#[test]
fn test_format_7_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 4).unwrap();
}

#[test]
fn test_format_7_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 5).unwrap();
}

#[test]
fn test_format_7_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 6).unwrap();
}

#[test]
fn test_format_7_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 7).unwrap();
}

#[test]
fn test_format_7_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 8).unwrap();
}

#[test]
fn test_format_7_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 9).unwrap();
}

#[test]
fn test_format_8_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_format_8_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_format_8_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 2).unwrap();
}

#[test]
fn test_format_8_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 3).unwrap();
}

#[test]
fn test_format_8_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 4).unwrap();
}

#[test]
fn test_format_8_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 5).unwrap();
}

#[test]
fn test_format_8_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 6).unwrap();
}

#[test]
fn test_format_8_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 7).unwrap();
}

#[test]
fn test_format_8_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 8).unwrap();
}

#[test]
fn test_format_8_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 9).unwrap();
}

#[test]
fn test_format_8_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 10).unwrap();
}

#[test]
fn test_format_8_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 11).unwrap();
}

#[test]
fn test_format_8_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 12).unwrap();
}

#[test]
fn test_format_8_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 13).unwrap();
}

#[test]
fn test_format_8_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 14).unwrap();
}

#[test]
fn test_format_8_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 15).unwrap();
}

#[test]
fn test_format_8_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 16).unwrap();
}

#[test]
fn test_format_8_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 17).unwrap();
}

#[test]
fn test_format_8_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 18).unwrap();
}

#[test]
fn test_format_8_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 19).unwrap();
}

#[test]
fn test_format_8_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 20).unwrap();
}

#[test]
fn test_format_8_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 21).unwrap();
}

#[test]
fn test_format_8_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 22).unwrap();
}

#[test]
fn test_format_8_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 23).unwrap();
}

#[test]
fn test_format_8_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 24).unwrap();
}

#[test]
fn test_format_8_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 25).unwrap();
}

#[test]
fn test_format_8_26() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 26).unwrap();
}

#[test]
fn test_format_8_27() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 27).unwrap();
}

#[test]
fn test_format_8_28() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 28).unwrap();
}

#[test]
fn test_format_8_29() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 29).unwrap();
}

#[test]
fn test_format_8_30() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 30).unwrap();
}

#[test]
fn test_format_8_31() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 31).unwrap();
}

#[test]
fn test_format_8_32() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 32).unwrap();
}

#[test]
fn test_format_8_33() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 33).unwrap();
}

#[test]
fn test_format_8_34() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 34).unwrap();
}

#[test]
fn test_format_8_35() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 35).unwrap();
}

#[test]
fn test_format_8_36() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 36).unwrap();
}

#[test]
fn test_format_8_37() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 37).unwrap();
}

#[test]
fn test_format_8_38() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 38).unwrap();
}

#[test]
fn test_format_8_39() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 39).unwrap();
}

#[test]
fn test_format_8_40() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 40).unwrap();
}

#[test]
fn test_format_8_41() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 41).unwrap();
}

#[test]
fn test_format_8_42() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 42).unwrap();
}

#[test]
fn test_format_8_43() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 43).unwrap();
}

#[test]
fn test_format_8_44() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 44).unwrap();
}

#[test]
fn test_format_8_45() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 45).unwrap();
}

#[test]
fn test_format_8_46() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 46).unwrap();
}

#[test]
fn test_format_8_47() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 47).unwrap();
}

#[test]
fn test_format_8_48() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 48).unwrap();
}

#[test]
fn test_format_8_49() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 49).unwrap();
}

#[test]
fn test_format_8_50() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 50).unwrap();
}

#[test]
fn test_format_8_51() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 51).unwrap();
}

#[test]
fn test_format_8_52() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 52).unwrap();
}

#[test]
fn test_format_8_53() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 53).unwrap();
}

#[test]
fn test_format_8_54() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 54).unwrap();
}

#[test]
fn test_format_8_55() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 55).unwrap();
}

#[test]
fn test_format_8_56() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 56).unwrap();
}

#[test]
fn test_format_9_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_format_9_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_format_9_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_format_9_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 3).unwrap();
}

#[test]
fn test_format_9_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 4).unwrap();
}

#[test]
fn test_format_9_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 5).unwrap();
}

#[test]
fn test_format_9_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 6).unwrap();
}

#[test]
fn test_format_9_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 7).unwrap();
}

#[test]
fn test_format_9_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 8).unwrap();
}

#[test]
fn test_format_9_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 9).unwrap();
}

#[test]
fn test_format_9_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 10).unwrap();
}

#[test]
fn test_format_9_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 11).unwrap();
}

#[test]
fn test_format_9_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 12).unwrap();
}

#[test]
fn test_format_9_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 13).unwrap();
}

#[test]
fn test_format_9_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 14).unwrap();
}

#[test]
fn test_format_9_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 15).unwrap();
}

#[test]
fn test_format_9_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 16).unwrap();
}

#[test]
fn test_format_9_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 17).unwrap();
}

#[test]
fn test_format_9_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 18).unwrap();
}

#[test]
fn test_format_9_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 19).unwrap();
}

#[test]
fn test_format_10_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_format_10_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 1).unwrap();
}

#[test]
fn test_format_10_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 2).unwrap();
}

#[test]
fn test_format_10_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 3).unwrap();
}

#[test]
fn test_format_10_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 4).unwrap();
}

#[test]
fn test_format_10_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 5).unwrap();
}

#[test]
fn test_format_10_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 6).unwrap();
}

#[test]
fn test_format_10_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 7).unwrap();
}

#[test]
fn test_format_10_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 8).unwrap();
}

#[test]
fn test_format_10_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 9).unwrap();
}

#[test]
fn test_format_10_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 10).unwrap();
}

#[test]
fn test_format_10_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 11).unwrap();
}

#[test]
fn test_format_10_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 12).unwrap();
}

#[test]
fn test_format_10_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 13).unwrap();
}

#[test]
fn test_format_10_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 14).unwrap();
}

#[test]
fn test_format_10_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 15).unwrap();
}

#[test]
fn test_format_11_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_format_11_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_format_11_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 2).unwrap();
}

#[test]
fn test_format_11_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 3).unwrap();
}

#[test]
fn test_format_11_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 4).unwrap();
}

#[test]
fn test_format_11_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 5).unwrap();
}

#[test]
fn test_format_11_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 6).unwrap();
}

#[test]
fn test_format_11_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 7).unwrap();
}

#[test]
fn test_format_11_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 8).unwrap();
}

#[test]
fn test_format_11_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 9).unwrap();
}

#[test]
fn test_format_11_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 10).unwrap();
}

#[test]
fn test_format_11_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 11).unwrap();
}

#[test]
fn test_format_11_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 12).unwrap();
}

#[test]
fn test_format_11_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 13).unwrap();
}

#[test]
fn test_format_11_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 14).unwrap();
}

#[test]
fn test_format_11_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 15).unwrap();
}

#[test]
fn test_format_11_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 16).unwrap();
}

#[test]
fn test_format_11_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 17).unwrap();
}

#[test]
fn test_format_11_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 18).unwrap();
}

#[test]
fn test_format_11_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 19).unwrap();
}

#[test]
fn test_format_11_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 20).unwrap();
}

#[test]
fn test_format_11_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 21).unwrap();
}

#[test]
fn test_format_11_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 22).unwrap();
}

#[test]
fn test_format_11_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 23).unwrap();
}

#[test]
fn test_format_11_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 24).unwrap();
}

#[test]
fn test_format_11_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 25).unwrap();
}

#[test]
fn test_format_11_26() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 26).unwrap();
}

#[test]
fn test_format_11_27() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 27).unwrap();
}

#[test]
fn test_format_11_28() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 28).unwrap();
}

#[test]
fn test_format_11_29() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 29).unwrap();
}

#[test]
fn test_format_11_30() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 30).unwrap();
}

#[test]
fn test_format_11_31() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 31).unwrap();
}

#[test]
fn test_format_11_32() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 32).unwrap();
}

#[test]
fn test_format_11_33() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 33).unwrap();
}

#[test]
fn test_format_11_34() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 34).unwrap();
}

#[test]
fn test_format_11_35() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 35).unwrap();
}

#[test]
fn test_format_11_36() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 36).unwrap();
}

#[test]
fn test_format_11_37() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 37).unwrap();
}

#[test]
fn test_format_11_38() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 38).unwrap();
}

#[test]
fn test_format_11_39() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 39).unwrap();
}

#[test]
fn test_format_12_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_format_12_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 1).unwrap();
}

#[test]
fn test_format_12_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 2).unwrap();
}

#[test]
fn test_format_12_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 3).unwrap();
}

#[test]
fn test_format_12_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 4).unwrap();
}

#[test]
fn test_format_12_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 5).unwrap();
}

#[test]
fn test_format_12_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 6).unwrap();
}

#[test]
fn test_format_12_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 7).unwrap();
}

#[test]
fn test_format_12_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 8).unwrap();
}

#[test]
fn test_format_12_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 9).unwrap();
}

#[test]
fn test_format_12_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 10).unwrap();
}

#[test]
fn test_format_12_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 11).unwrap();
}

#[test]
fn test_format_12_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 12).unwrap();
}

#[test]
fn test_format_13_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
}

#[test]
fn test_format_13_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
}

#[test]
fn test_format_13_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 2).unwrap();
}

#[test]
fn test_format_13_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 3).unwrap();
}

#[test]
fn test_format_13_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 4).unwrap();
}

#[test]
fn test_format_13_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 5).unwrap();
}

#[test]
fn test_format_13_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 6).unwrap();
}

#[test]
fn test_format_13_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 7).unwrap();
}

#[test]
fn test_format_13_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 8).unwrap();
}

#[test]
fn test_format_13_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 9).unwrap();
}

#[test]
fn test_format_13_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 10).unwrap();
}

#[test]
fn test_format_13_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 11).unwrap();
}

#[test]
fn test_format_13_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 12).unwrap();
}

#[test]
fn test_format_13_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 13).unwrap();
}

#[test]
fn test_format_13_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 14).unwrap();
}

#[test]
fn test_format_14_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 0).unwrap();
}

#[test]
fn test_format_14_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 1).unwrap();
}

#[test]
fn test_format_14_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 2).unwrap();
}

#[test]
fn test_format_14_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 3).unwrap();
}

#[test]
fn test_format_14_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 4).unwrap();
}

#[test]
fn test_format_14_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 5).unwrap();
}

#[test]
fn test_format_14_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 6).unwrap();
}

#[test]
fn test_format_14_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 7).unwrap();
}

#[test]
fn test_format_14_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 8).unwrap();
}

#[test]
fn test_format_14_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 9).unwrap();
}

#[test]
fn test_format_14_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 10).unwrap();
}

#[test]
fn test_format_14_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 11).unwrap();
}

#[test]
fn test_format_14_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 12).unwrap();
}

#[test]
fn test_format_14_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 13).unwrap();
}

#[test]
fn test_format_14_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 14).unwrap();
}

#[test]
fn test_format_14_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 15).unwrap();
}

#[test]
fn test_format_14_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 16).unwrap();
}

#[test]
fn test_format_14_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 17).unwrap();
}

#[test]
fn test_format_14_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 18).unwrap();
}

#[test]
fn test_format_14_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 19).unwrap();
}

#[test]
fn test_format_14_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 20).unwrap();
}

#[test]
fn test_format_14_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 21).unwrap();
}

#[test]
fn test_format_14_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 22).unwrap();
}

#[test]
fn test_format_14_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 23).unwrap();
}

#[test]
fn test_format_14_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 24).unwrap();
}

#[test]
fn test_format_14_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 25).unwrap();
}

#[test]
fn test_format_14_26() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 26).unwrap();
}

#[test]
fn test_format_14_27() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 27).unwrap();
}

#[test]
fn test_format_14_28() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 28).unwrap();
}

#[test]
fn test_format_14_29() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 29).unwrap();
}

#[test]
fn test_format_14_30() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 30).unwrap();
}

#[test]
fn test_format_14_31() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 31).unwrap();
}

#[test]
fn test_format_14_32() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 32).unwrap();
}

#[test]
fn test_format_14_33() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 33).unwrap();
}

#[test]
fn test_format_14_34() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 34).unwrap();
}

#[test]
fn test_format_14_35() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 35).unwrap();
}

#[test]
fn test_format_14_36() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 36).unwrap();
}

#[test]
fn test_format_14_37() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 37).unwrap();
}

#[test]
fn test_format_15_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 0).unwrap();
}

#[test]
fn test_format_15_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 1).unwrap();
}

#[test]
fn test_format_15_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 2).unwrap();
}

#[test]
fn test_format_15_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 3).unwrap();
}

#[test]
fn test_format_15_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 4).unwrap();
}

#[test]
fn test_format_15_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 5).unwrap();
}

#[test]
fn test_format_15_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 6).unwrap();
}

#[test]
fn test_format_15_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 7).unwrap();
}

#[test]
fn test_format_16_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 0).unwrap();
}

#[test]
fn test_format_16_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 1).unwrap();
}

#[test]
fn test_format_16_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 2).unwrap();
}

#[test]
fn test_format_16_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 3).unwrap();
}

#[test]
fn test_format_16_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 4).unwrap();
}

#[test]
fn test_format_16_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 5).unwrap();
}

#[test]
fn test_format_16_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 6).unwrap();
}

#[test]
fn test_format_16_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 7).unwrap();
}

#[test]
fn test_format_16_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 8).unwrap();
}

#[test]
fn test_format_16_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 9).unwrap();
}

#[test]
fn test_format_16_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 10).unwrap();
}

#[test]
fn test_format_16_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 11).unwrap();
}

#[test]
fn test_format_16_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 12).unwrap();
}

#[test]
fn test_format_16_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 13).unwrap();
}

#[test]
fn test_format_16_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 14).unwrap();
}

#[test]
fn test_format_16_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 15).unwrap();
}

#[test]
fn test_format_16_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 16).unwrap();
}

#[test]
fn test_format_16_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 16, 17).unwrap();
}

#[test]
fn test_format_17_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 0).unwrap();
}

#[test]
fn test_format_17_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 1).unwrap();
}

#[test]
fn test_format_17_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 2).unwrap();
}

#[test]
fn test_format_17_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 3).unwrap();
}

#[test]
fn test_format_17_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 4).unwrap();
}

#[test]
fn test_format_17_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 5).unwrap();
}

#[test]
fn test_format_17_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 6).unwrap();
}

#[test]
fn test_format_17_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 7).unwrap();
}

#[test]
fn test_format_17_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 8).unwrap();
}

#[test]
fn test_format_17_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 9).unwrap();
}

#[test]
fn test_format_17_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 10).unwrap();
}

#[test]
fn test_format_17_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 11).unwrap();
}

#[test]
fn test_format_17_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 12).unwrap();
}

#[test]
fn test_format_17_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 13).unwrap();
}

#[test]
fn test_format_17_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 14).unwrap();
}

#[test]
fn test_format_17_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 15).unwrap();
}

#[test]
fn test_format_17_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 16).unwrap();
}

#[test]
fn test_format_17_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 17).unwrap();
}

#[test]
fn test_format_17_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 18).unwrap();
}

#[test]
fn test_format_17_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 19).unwrap();
}

#[test]
fn test_format_17_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 20).unwrap();
}

#[test]
fn test_format_17_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 21).unwrap();
}

#[test]
fn test_format_17_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 22).unwrap();
}

#[test]
fn test_format_17_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 23).unwrap();
}

#[test]
fn test_format_17_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 24).unwrap();
}

#[test]
fn test_format_17_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 25).unwrap();
}

#[test]
fn test_format_17_26() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 26).unwrap();
}

#[test]
fn test_format_17_27() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 27).unwrap();
}

#[test]
fn test_format_17_28() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 28).unwrap();
}

#[test]
fn test_format_17_29() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 29).unwrap();
}

#[test]
fn test_format_17_30() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 30).unwrap();
}

#[test]
fn test_format_17_31() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 31).unwrap();
}

#[test]
fn test_format_17_32() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 32).unwrap();
}

#[test]
fn test_format_17_33() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 33).unwrap();
}

#[test]
fn test_format_17_34() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 34).unwrap();
}

#[test]
fn test_format_17_35() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 35).unwrap();
}

#[test]
fn test_format_17_36() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 36).unwrap();
}

#[test]
fn test_format_17_37() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 37).unwrap();
}

#[test]
fn test_format_17_38() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 38).unwrap();
}

#[test]
fn test_format_17_39() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 39).unwrap();
}

#[test]
fn test_format_17_40() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 40).unwrap();
}

#[test]
fn test_format_17_41() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 41).unwrap();
}

#[test]
fn test_format_17_42() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 42).unwrap();
}

#[test]
fn test_format_17_43() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 43).unwrap();
}

#[test]
fn test_format_17_44() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 44).unwrap();
}

#[test]
fn test_format_17_45() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 17, 45).unwrap();
}

#[test]
fn test_format_18_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 18, 0).unwrap();
}

#[test]
fn test_format_18_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 18, 1).unwrap();
}

#[test]
fn test_format_18_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 18, 2).unwrap();
}

#[test]
fn test_format_18_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 18, 3).unwrap();
}

#[test]
fn test_format_18_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 18, 4).unwrap();
}

#[test]
fn test_format_18_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 18, 5).unwrap();
}

#[test]
fn test_format_18_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 18, 6).unwrap();
}

#[test]
fn test_format_19_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 0).unwrap();
}

#[test]
fn test_format_19_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 1).unwrap();
}

#[test]
fn test_format_19_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 2).unwrap();
}

#[test]
fn test_format_19_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 3).unwrap();
}

#[test]
fn test_format_19_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 4).unwrap();
}

#[test]
fn test_format_19_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 5).unwrap();
}

#[test]
fn test_format_19_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 6).unwrap();
}

#[test]
fn test_format_19_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 7).unwrap();
}

#[test]
fn test_format_19_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 8).unwrap();
}

#[test]
fn test_format_19_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 9).unwrap();
}

#[test]
fn test_format_19_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 10).unwrap();
}

#[test]
fn test_format_19_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 11).unwrap();
}

#[test]
fn test_format_19_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 12).unwrap();
}

#[test]
fn test_format_19_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 13).unwrap();
}

#[test]
fn test_format_19_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 19, 14).unwrap();
}

#[test]
fn test_format_20_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 0).unwrap();
}

#[test]
fn test_format_20_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 1).unwrap();
}

#[test]
fn test_format_20_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 2).unwrap();
}

#[test]
fn test_format_20_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 3).unwrap();
}

#[test]
fn test_format_20_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 4).unwrap();
}

#[test]
fn test_format_20_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 5).unwrap();
}

#[test]
fn test_format_20_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 6).unwrap();
}

#[test]
fn test_format_20_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 7).unwrap();
}

#[test]
fn test_format_20_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 8).unwrap();
}

#[test]
fn test_format_20_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 20, 9).unwrap();
}

#[test]
fn test_format_21_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 0).unwrap();
}

#[test]
fn test_format_21_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 1).unwrap();
}

#[test]
fn test_format_21_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 2).unwrap();
}

#[test]
fn test_format_21_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 3).unwrap();
}

#[test]
fn test_format_21_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 4).unwrap();
}

#[test]
fn test_format_21_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 5).unwrap();
}

#[test]
fn test_format_21_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 6).unwrap();
}

#[test]
fn test_format_21_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 7).unwrap();
}

#[test]
fn test_format_21_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 8).unwrap();
}

#[test]
fn test_format_21_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 9).unwrap();
}

#[test]
fn test_format_21_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 10).unwrap();
}

#[test]
fn test_format_21_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 11).unwrap();
}

#[test]
fn test_format_21_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 12).unwrap();
}

#[test]
fn test_format_21_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 13).unwrap();
}

#[test]
fn test_format_21_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 14).unwrap();
}

#[test]
fn test_format_21_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 15).unwrap();
}

#[test]
fn test_format_21_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 16).unwrap();
}

#[test]
fn test_format_21_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 17).unwrap();
}

#[test]
fn test_format_21_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 18).unwrap();
}

#[test]
fn test_format_21_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 19).unwrap();
}

#[test]
fn test_format_21_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 20).unwrap();
}

#[test]
fn test_format_21_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 21).unwrap();
}

#[test]
fn test_format_21_22() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 22).unwrap();
}

#[test]
fn test_format_21_23() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 23).unwrap();
}

#[test]
fn test_format_21_24() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 24).unwrap();
}

#[test]
fn test_format_21_25() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 25).unwrap();
}

#[test]
fn test_format_21_26() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 26).unwrap();
}

#[test]
fn test_format_21_27() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 27).unwrap();
}

#[test]
fn test_format_21_28() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 28).unwrap();
}

#[test]
fn test_format_21_29() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 29).unwrap();
}

#[test]
fn test_format_21_30() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 30).unwrap();
}

#[test]
fn test_format_21_31() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 31).unwrap();
}

#[test]
fn test_format_21_32() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 32).unwrap();
}

#[test]
fn test_format_21_33() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 33).unwrap();
}

#[test]
fn test_format_21_34() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 34).unwrap();
}

#[test]
fn test_format_21_35() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 21, 35).unwrap();
}

#[test]
fn test_format_22_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 0).unwrap();
}

#[test]
fn test_format_22_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 1).unwrap();
}

#[test]
fn test_format_22_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 2).unwrap();
}

#[test]
fn test_format_22_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 3).unwrap();
}

#[test]
fn test_format_22_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 4).unwrap();
}

#[test]
fn test_format_22_5() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 5).unwrap();
}

#[test]
fn test_format_22_6() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 6).unwrap();
}

#[test]
fn test_format_22_7() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 7).unwrap();
}

#[test]
fn test_format_22_8() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 8).unwrap();
}

#[test]
fn test_format_22_9() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 9).unwrap();
}

#[test]
fn test_format_22_10() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 10).unwrap();
}

#[test]
fn test_format_22_11() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 11).unwrap();
}

#[test]
fn test_format_22_12() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 12).unwrap();
}

#[test]
fn test_format_22_13() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 13).unwrap();
}

#[test]
fn test_format_22_14() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 14).unwrap();
}

#[test]
fn test_format_22_15() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 15).unwrap();
}

#[test]
fn test_format_22_16() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 16).unwrap();
}

#[test]
fn test_format_22_17() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 17).unwrap();
}

#[test]
fn test_format_22_18() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 18).unwrap();
}

#[test]
fn test_format_22_19() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 19).unwrap();
}

#[test]
fn test_format_22_20() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 20).unwrap();
}

#[test]
fn test_format_22_21() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 22, 21).unwrap();
}

#[test]
fn test_format_23_0() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 23, 0).unwrap();
}

#[test]
fn test_format_23_1() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 23, 1).unwrap();
}

#[test]
fn test_format_23_2() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 23, 2).unwrap();
}

#[test]
fn test_format_23_3() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 23, 3).unwrap();
}

#[test]
fn test_format_23_4() {
    let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 23, 4).unwrap();
}

#[test]
fn test_ref_0_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_ref_0_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_ref_1_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_ref_1_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_ref_1_2() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_ref_2_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_ref_2_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_ref_3_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_ref_3_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_ref_4_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_ref_5_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_ref_6_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_ref_6_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 1).unwrap();
}

#[test]
fn test_ref_7_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_ref_8_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_ref_9_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 0).unwrap();
}

#[test]
fn test_ref_9_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 1).unwrap();
}

#[test]
fn test_ref_9_2() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 9, 2).unwrap();
}

#[test]
fn test_ref_10_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 10, 0).unwrap();
}

#[test]
fn test_ref_11_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 0).unwrap();
}

#[test]
fn test_ref_11_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 1).unwrap();
}

#[test]
fn test_ref_11_2() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 2).unwrap();
}

#[test]
fn test_ref_11_3() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 11, 3).unwrap();
}

#[test]
fn test_ref_12_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
}

#[test]
fn test_ref_12_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 1).unwrap();
}

#[test]
fn test_ref_12_2() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 12, 2).unwrap();
}

#[test]
fn test_ref_13_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
}

#[test]
fn test_ref_13_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
}

#[test]
fn test_ref_14_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 0).unwrap();
}

#[test]
fn test_ref_14_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 14, 1).unwrap();
}

#[test]
fn test_ref_15_0() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 0).unwrap();
}

#[test]
fn test_ref_15_1() {
    let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 15, 1).unwrap();
}

#[test]
fn test_maximum_0_0() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_maximum_0_1() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_maximum_0_2() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_maximum_0_3() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_maximum_1_0() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_maximum_1_1() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_maximum_1_2() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_maximum_1_3() {
    let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 3).unwrap();
}

#[test]
fn test_min_length_0_0() {
    let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_min_length_0_1() {
    let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_min_length_0_2() {
    let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_min_length_0_3() {
    let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_min_length_0_4() {
    let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_min_length_1_0() {
    let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_min_length_1_1() {
    let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_max_items_0_0() {
    let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_max_items_0_1() {
    let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_max_items_0_2() {
    let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_max_items_0_3() {
    let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_max_items_1_0() {
    let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_max_items_1_1() {
    let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_max_items_2_0() {
    let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_contains_0_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_contains_0_1() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_contains_0_2() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_contains_0_3() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_contains_0_4() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}

#[test]
fn test_contains_0_5() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 5).unwrap();
}

#[test]
fn test_contains_1_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 0).unwrap();
}

#[test]
fn test_contains_1_1() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 1).unwrap();
}

#[test]
fn test_contains_1_2() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 1, 2).unwrap();
}

#[test]
fn test_contains_2_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 0).unwrap();
}

#[test]
fn test_contains_2_1() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 2, 1).unwrap();
}

#[test]
fn test_contains_3_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 0).unwrap();
}

#[test]
fn test_contains_3_1() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 1).unwrap();
}

#[test]
fn test_contains_3_2() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 3, 2).unwrap();
}

#[test]
fn test_contains_4_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 0).unwrap();
}

#[test]
fn test_contains_4_1() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
}

#[test]
fn test_contains_4_2() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 2).unwrap();
}

#[test]
fn test_contains_4_3() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 4, 3).unwrap();
}

#[test]
fn test_contains_5_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
}

#[test]
fn test_contains_5_1() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
}

#[test]
fn test_contains_6_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 6, 0).unwrap();
}

#[test]
fn test_contains_7_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 7, 0).unwrap();
}

#[test]
fn test_contains_8_0() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 0).unwrap();
}

#[test]
fn test_contains_8_1() {
    let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 8, 1).unwrap();
}

#[test]
fn test_merger_0_0() {
    let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}

#[test]
fn test_merger_0_1() {
    let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 1).unwrap();
}

#[test]
fn test_merger_0_2() {
    let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 2).unwrap();
}

#[test]
fn test_merger_0_3() {
    let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 3).unwrap();
}

#[test]
fn test_merger_0_4() {
    let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR"));
    crate::tests::runner::run_test_case(&path, 0, 4).unwrap();
}
