warning: function `test_uniqueItems_0` should have a snake case name
  --> tests/tests.rs:52:4
   |
52 | fn test_uniqueItems_0() {
   |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_unique_items_0`
   |
   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default

warning: function `test_uniqueItems_1` should have a snake case name
  --> tests/tests.rs:58:4
   |
58 | fn test_uniqueItems_1() {
   |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_unique_items_1`

warning: function `test_uniqueItems_2` should have a snake case name
  --> tests/tests.rs:64:4
   |
64 | fn test_uniqueItems_2() {
   |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_unique_items_2`

warning: function `test_uniqueItems_3` should have a snake case name
  --> tests/tests.rs:70:4
   |
70 | fn test_uniqueItems_3() {
   |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_unique_items_3`

warning: function `test_uniqueItems_4` should have a snake case name
  --> tests/tests.rs:76:4
   |
76 | fn test_uniqueItems_4() {
   |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_unique_items_4`

warning: function `test_uniqueItems_5` should have a snake case name
  --> tests/tests.rs:82:4
   |
82 | fn test_uniqueItems_5() {
   |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_unique_items_5`

warning: function `test_uniqueItems_6` should have a snake case name
  --> tests/tests.rs:88:4
   |
88 | fn test_uniqueItems_6() {
   |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_unique_items_6`

warning: function `test_minItems_0` should have a snake case name
  --> tests/tests.rs:94:4
   |
94 | fn test_minItems_0() {
   |    ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_items_0`

warning: function `test_minItems_1` should have a snake case name
   --> tests/tests.rs:100:4
    |
100 | fn test_minItems_1() {
    |    ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_items_1`

warning: function `test_minItems_2` should have a snake case name
   --> tests/tests.rs:106:4
    |
106 | fn test_minItems_2() {
    |    ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_items_2`

warning: function `test_exclusiveMinimum_0` should have a snake case name
   --> tests/tests.rs:160:4
    |
160 | fn test_exclusiveMinimum_0() {
    |    ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_exclusive_minimum_0`

warning: function `test_anyOf_0` should have a snake case name
   --> tests/tests.rs:274:4
    |
274 | fn test_anyOf_0() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_0`

warning: function `test_anyOf_1` should have a snake case name
   --> tests/tests.rs:280:4
    |
280 | fn test_anyOf_1() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_1`

warning: function `test_anyOf_2` should have a snake case name
   --> tests/tests.rs:286:4
    |
286 | fn test_anyOf_2() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_2`

warning: function `test_anyOf_3` should have a snake case name
   --> tests/tests.rs:292:4
    |
292 | fn test_anyOf_3() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_3`

warning: function `test_anyOf_4` should have a snake case name
   --> tests/tests.rs:298:4
    |
298 | fn test_anyOf_4() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_4`

warning: function `test_anyOf_5` should have a snake case name
   --> tests/tests.rs:304:4
    |
304 | fn test_anyOf_5() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_5`

warning: function `test_anyOf_6` should have a snake case name
   --> tests/tests.rs:310:4
    |
310 | fn test_anyOf_6() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_6`

warning: function `test_anyOf_7` should have a snake case name
   --> tests/tests.rs:316:4
    |
316 | fn test_anyOf_7() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_7`

warning: function `test_anyOf_8` should have a snake case name
   --> tests/tests.rs:322:4
    |
322 | fn test_anyOf_8() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_8`

warning: function `test_anyOf_9` should have a snake case name
   --> tests/tests.rs:328:4
    |
328 | fn test_anyOf_9() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_any_of_9`

warning: function `test_propertyNames_0` should have a snake case name
   --> tests/tests.rs:334:4
    |
334 | fn test_propertyNames_0() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_property_names_0`

warning: function `test_propertyNames_1` should have a snake case name
   --> tests/tests.rs:340:4
    |
340 | fn test_propertyNames_1() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_property_names_1`

warning: function `test_propertyNames_2` should have a snake case name
   --> tests/tests.rs:346:4
    |
346 | fn test_propertyNames_2() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_property_names_2`

warning: function `test_propertyNames_3` should have a snake case name
   --> tests/tests.rs:352:4
    |
352 | fn test_propertyNames_3() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_property_names_3`

warning: function `test_propertyNames_4` should have a snake case name
   --> tests/tests.rs:358:4
    |
358 | fn test_propertyNames_4() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_property_names_4`

warning: function `test_propertyNames_5` should have a snake case name
   --> tests/tests.rs:364:4
    |
364 | fn test_propertyNames_5() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_property_names_5`

warning: function `test_propertyNames_6` should have a snake case name
   --> tests/tests.rs:370:4
    |
370 | fn test_propertyNames_6() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_property_names_6`

warning: function `test_minProperties_0` should have a snake case name
   --> tests/tests.rs:646:4
    |
646 | fn test_minProperties_0() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_properties_0`

warning: function `test_minProperties_1` should have a snake case name
   --> tests/tests.rs:652:4
    |
652 | fn test_minProperties_1() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_properties_1`

warning: function `test_minProperties_2` should have a snake case name
   --> tests/tests.rs:658:4
    |
658 | fn test_minProperties_2() {
    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_properties_2`

warning: function `test_minContains_0` should have a snake case name
   --> tests/tests.rs:664:4
    |
664 | fn test_minContains_0() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_0`

warning: function `test_minContains_1` should have a snake case name
   --> tests/tests.rs:670:4
    |
670 | fn test_minContains_1() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_1`

warning: function `test_minContains_2` should have a snake case name
   --> tests/tests.rs:676:4
    |
676 | fn test_minContains_2() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_2`

warning: function `test_minContains_3` should have a snake case name
   --> tests/tests.rs:682:4
    |
682 | fn test_minContains_3() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_3`

warning: function `test_minContains_4` should have a snake case name
   --> tests/tests.rs:688:4
    |
688 | fn test_minContains_4() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_4`

warning: function `test_minContains_5` should have a snake case name
   --> tests/tests.rs:694:4
    |
694 | fn test_minContains_5() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_5`

warning: function `test_minContains_6` should have a snake case name
   --> tests/tests.rs:700:4
    |
700 | fn test_minContains_6() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_6`

warning: function `test_minContains_7` should have a snake case name
   --> tests/tests.rs:706:4
    |
706 | fn test_minContains_7() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_7`

warning: function `test_minContains_8` should have a snake case name
   --> tests/tests.rs:712:4
    |
712 | fn test_minContains_8() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_contains_8`

warning: function `test_maxContains_0` should have a snake case name
   --> tests/tests.rs:796:4
    |
796 | fn test_maxContains_0() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_contains_0`

warning: function `test_maxContains_1` should have a snake case name
   --> tests/tests.rs:802:4
    |
802 | fn test_maxContains_1() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_contains_1`

warning: function `test_maxContains_2` should have a snake case name
   --> tests/tests.rs:808:4
    |
808 | fn test_maxContains_2() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_contains_2`

warning: function `test_maxContains_3` should have a snake case name
   --> tests/tests.rs:814:4
    |
814 | fn test_maxContains_3() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_contains_3`

warning: function `test_maxContains_4` should have a snake case name
   --> tests/tests.rs:820:4
    |
820 | fn test_maxContains_4() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_contains_4`

warning: function `test_maxLength_0` should have a snake case name
   --> tests/tests.rs:826:4
    |
826 | fn test_maxLength_0() {
    |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_length_0`

warning: function `test_maxLength_1` should have a snake case name
   --> tests/tests.rs:832:4
    |
832 | fn test_maxLength_1() {
    |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_length_1`

warning: function `test_dependentSchemas_0` should have a snake case name
   --> tests/tests.rs:838:4
    |
838 | fn test_dependentSchemas_0() {
    |    ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_schemas_0`

warning: function `test_dependentSchemas_1` should have a snake case name
   --> tests/tests.rs:844:4
    |
844 | fn test_dependentSchemas_1() {
    |    ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_schemas_1`

warning: function `test_dependentSchemas_2` should have a snake case name
   --> tests/tests.rs:850:4
    |
850 | fn test_dependentSchemas_2() {
    |    ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_schemas_2`

warning: function `test_dependentSchemas_3` should have a snake case name
   --> tests/tests.rs:856:4
    |
856 | fn test_dependentSchemas_3() {
    |    ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_schemas_3`

warning: function `test_exclusiveMaximum_0` should have a snake case name
   --> tests/tests.rs:862:4
    |
862 | fn test_exclusiveMaximum_0() {
    |    ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_exclusive_maximum_0`

warning: function `test_prefixItems_0` should have a snake case name
   --> tests/tests.rs:868:4
    |
868 | fn test_prefixItems_0() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_prefix_items_0`

warning: function `test_prefixItems_1` should have a snake case name
   --> tests/tests.rs:874:4
    |
874 | fn test_prefixItems_1() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_prefix_items_1`

warning: function `test_prefixItems_2` should have a snake case name
   --> tests/tests.rs:880:4
    |
880 | fn test_prefixItems_2() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_prefix_items_2`

warning: function `test_prefixItems_3` should have a snake case name
   --> tests/tests.rs:886:4
    |
886 | fn test_prefixItems_3() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_prefix_items_3`

warning: function `test_prefixItems_4` should have a snake case name
   --> tests/tests.rs:892:4
    |
892 | fn test_prefixItems_4() {
    |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_prefix_items_4`

warning: function `test_oneOf_0` should have a snake case name
   --> tests/tests.rs:910:4
    |
910 | fn test_oneOf_0() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_0`

warning: function `test_oneOf_1` should have a snake case name
   --> tests/tests.rs:916:4
    |
916 | fn test_oneOf_1() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_1`

warning: function `test_oneOf_2` should have a snake case name
   --> tests/tests.rs:922:4
    |
922 | fn test_oneOf_2() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_2`

warning: function `test_oneOf_3` should have a snake case name
   --> tests/tests.rs:928:4
    |
928 | fn test_oneOf_3() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_3`

warning: function `test_oneOf_4` should have a snake case name
   --> tests/tests.rs:934:4
    |
934 | fn test_oneOf_4() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_4`

warning: function `test_oneOf_5` should have a snake case name
   --> tests/tests.rs:940:4
    |
940 | fn test_oneOf_5() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_5`

warning: function `test_oneOf_6` should have a snake case name
   --> tests/tests.rs:946:4
    |
946 | fn test_oneOf_6() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_6`

warning: function `test_oneOf_7` should have a snake case name
   --> tests/tests.rs:952:4
    |
952 | fn test_oneOf_7() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_7`

warning: function `test_oneOf_8` should have a snake case name
   --> tests/tests.rs:958:4
    |
958 | fn test_oneOf_8() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_8`

warning: function `test_oneOf_9` should have a snake case name
   --> tests/tests.rs:964:4
    |
964 | fn test_oneOf_9() {
    |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_9`

warning: function `test_oneOf_10` should have a snake case name
   --> tests/tests.rs:970:4
    |
970 | fn test_oneOf_10() {
    |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_10`

warning: function `test_oneOf_11` should have a snake case name
   --> tests/tests.rs:976:4
    |
976 | fn test_oneOf_11() {
    |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_11`

warning: function `test_oneOf_12` should have a snake case name
   --> tests/tests.rs:982:4
    |
982 | fn test_oneOf_12() {
    |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_one_of_12`

warning: function `test_emptyString_0` should have a snake case name
    --> tests/tests.rs:1072:4
     |
1072 | fn test_emptyString_0() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_empty_string_0`

warning: function `test_maxProperties_0` should have a snake case name
    --> tests/tests.rs:1090:4
     |
1090 | fn test_maxProperties_0() {
     |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_properties_0`

warning: function `test_maxProperties_1` should have a snake case name
    --> tests/tests.rs:1096:4
     |
1096 | fn test_maxProperties_1() {
     |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_properties_1`

warning: function `test_maxProperties_2` should have a snake case name
    --> tests/tests.rs:1102:4
     |
1102 | fn test_maxProperties_2() {
     |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_properties_2`

warning: function `test_maxProperties_3` should have a snake case name
    --> tests/tests.rs:1108:4
     |
1108 | fn test_maxProperties_3() {
     |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_properties_3`

warning: function `test_dependentRequired_0` should have a snake case name
    --> tests/tests.rs:1114:4
     |
1114 | fn test_dependentRequired_0() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_required_0`

warning: function `test_dependentRequired_1` should have a snake case name
    --> tests/tests.rs:1120:4
     |
1120 | fn test_dependentRequired_1() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_required_1`

warning: function `test_dependentRequired_2` should have a snake case name
    --> tests/tests.rs:1126:4
     |
1126 | fn test_dependentRequired_2() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_required_2`

warning: function `test_dependentRequired_3` should have a snake case name
    --> tests/tests.rs:1132:4
     |
1132 | fn test_dependentRequired_3() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_required_3`

warning: function `test_dependentRequired_4` should have a snake case name
    --> tests/tests.rs:1138:4
     |
1138 | fn test_dependentRequired_4() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dependent_required_4`

warning: function `test_multipleOf_0` should have a snake case name
    --> tests/tests.rs:1252:4
     |
1252 | fn test_multipleOf_0() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_multiple_of_0`

warning: function `test_multipleOf_1` should have a snake case name
    --> tests/tests.rs:1258:4
     |
1258 | fn test_multipleOf_1() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_multiple_of_1`

warning: function `test_multipleOf_2` should have a snake case name
    --> tests/tests.rs:1264:4
     |
1264 | fn test_multipleOf_2() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_multiple_of_2`

warning: function `test_multipleOf_3` should have a snake case name
    --> tests/tests.rs:1270:4
     |
1270 | fn test_multipleOf_3() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_multiple_of_3`

warning: function `test_patternProperties_0` should have a snake case name
    --> tests/tests.rs:1276:4
     |
1276 | fn test_patternProperties_0() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_pattern_properties_0`

warning: function `test_patternProperties_1` should have a snake case name
    --> tests/tests.rs:1282:4
     |
1282 | fn test_patternProperties_1() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_pattern_properties_1`

warning: function `test_patternProperties_2` should have a snake case name
    --> tests/tests.rs:1288:4
     |
1288 | fn test_patternProperties_2() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_pattern_properties_2`

warning: function `test_patternProperties_3` should have a snake case name
    --> tests/tests.rs:1294:4
     |
1294 | fn test_patternProperties_3() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_pattern_properties_3`

warning: function `test_patternProperties_4` should have a snake case name
    --> tests/tests.rs:1300:4
     |
1300 | fn test_patternProperties_4() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_pattern_properties_4`

warning: function `test_patternProperties_5` should have a snake case name
    --> tests/tests.rs:1306:4
     |
1306 | fn test_patternProperties_5() {
     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_pattern_properties_5`

warning: function `test_allOf_0` should have a snake case name
    --> tests/tests.rs:1336:4
     |
1336 | fn test_allOf_0() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_0`

warning: function `test_allOf_1` should have a snake case name
    --> tests/tests.rs:1342:4
     |
1342 | fn test_allOf_1() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_1`

warning: function `test_allOf_2` should have a snake case name
    --> tests/tests.rs:1348:4
     |
1348 | fn test_allOf_2() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_2`

warning: function `test_allOf_3` should have a snake case name
    --> tests/tests.rs:1354:4
     |
1354 | fn test_allOf_3() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_3`

warning: function `test_allOf_4` should have a snake case name
    --> tests/tests.rs:1360:4
     |
1360 | fn test_allOf_4() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_4`

warning: function `test_allOf_5` should have a snake case name
    --> tests/tests.rs:1366:4
     |
1366 | fn test_allOf_5() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_5`

warning: function `test_allOf_6` should have a snake case name
    --> tests/tests.rs:1372:4
     |
1372 | fn test_allOf_6() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_6`

warning: function `test_allOf_7` should have a snake case name
    --> tests/tests.rs:1378:4
     |
1378 | fn test_allOf_7() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_7`

warning: function `test_allOf_8` should have a snake case name
    --> tests/tests.rs:1384:4
     |
1384 | fn test_allOf_8() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_8`

warning: function `test_allOf_9` should have a snake case name
    --> tests/tests.rs:1390:4
     |
1390 | fn test_allOf_9() {
     |    ^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_9`

warning: function `test_allOf_10` should have a snake case name
    --> tests/tests.rs:1396:4
     |
1396 | fn test_allOf_10() {
     |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_10`

warning: function `test_allOf_11` should have a snake case name
    --> tests/tests.rs:1402:4
     |
1402 | fn test_allOf_11() {
     |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_11`

warning: function `test_allOf_12` should have a snake case name
    --> tests/tests.rs:1408:4
     |
1408 | fn test_allOf_12() {
     |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_12`

warning: function `test_allOf_13` should have a snake case name
    --> tests/tests.rs:1414:4
     |
1414 | fn test_allOf_13() {
     |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_13`

warning: function `test_allOf_14` should have a snake case name
    --> tests/tests.rs:1420:4
     |
1420 | fn test_allOf_14() {
     |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_14`

warning: function `test_allOf_15` should have a snake case name
    --> tests/tests.rs:1426:4
     |
1426 | fn test_allOf_15() {
     |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_all_of_15`

warning: function `test_minLength_0` should have a snake case name
    --> tests/tests.rs:1828:4
     |
1828 | fn test_minLength_0() {
     |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_length_0`

warning: function `test_minLength_1` should have a snake case name
    --> tests/tests.rs:1834:4
     |
1834 | fn test_minLength_1() {
     |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_min_length_1`

warning: function `test_maxItems_0` should have a snake case name
    --> tests/tests.rs:1840:4
     |
1840 | fn test_maxItems_0() {
     |    ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_items_0`

warning: function `test_maxItems_1` should have a snake case name
    --> tests/tests.rs:1846:4
     |
1846 | fn test_maxItems_1() {
     |    ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_items_1`

warning: function `test_maxItems_2` should have a snake case name
    --> tests/tests.rs:1852:4
     |
1852 | fn test_maxItems_2() {
     |    ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_max_items_2`

warning: function `test_dynamicRef_0` should have a snake case name
    --> tests/tests.rs:1912:4
     |
1912 | fn test_dynamicRef_0() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_0`

warning: function `test_dynamicRef_1` should have a snake case name
    --> tests/tests.rs:1918:4
     |
1918 | fn test_dynamicRef_1() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_1`

warning: function `test_dynamicRef_2` should have a snake case name
    --> tests/tests.rs:1924:4
     |
1924 | fn test_dynamicRef_2() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_2`

warning: function `test_dynamicRef_3` should have a snake case name
    --> tests/tests.rs:1930:4
     |
1930 | fn test_dynamicRef_3() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_3`

warning: function `test_dynamicRef_4` should have a snake case name
    --> tests/tests.rs:1936:4
     |
1936 | fn test_dynamicRef_4() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_4`

warning: function `test_dynamicRef_5` should have a snake case name
    --> tests/tests.rs:1942:4
     |
1942 | fn test_dynamicRef_5() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_5`

warning: function `test_dynamicRef_6` should have a snake case name
    --> tests/tests.rs:1948:4
     |
1948 | fn test_dynamicRef_6() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_6`

warning: function `test_dynamicRef_7` should have a snake case name
    --> tests/tests.rs:1954:4
     |
1954 | fn test_dynamicRef_7() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_7`

warning: function `test_dynamicRef_8` should have a snake case name
    --> tests/tests.rs:1960:4
     |
1960 | fn test_dynamicRef_8() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_8`

warning: function `test_dynamicRef_9` should have a snake case name
    --> tests/tests.rs:1966:4
     |
1966 | fn test_dynamicRef_9() {
     |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_9`

warning: function `test_dynamicRef_10` should have a snake case name
    --> tests/tests.rs:1972:4
     |
1972 | fn test_dynamicRef_10() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_10`

warning: function `test_dynamicRef_11` should have a snake case name
    --> tests/tests.rs:1978:4
     |
1978 | fn test_dynamicRef_11() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_11`

warning: function `test_dynamicRef_12` should have a snake case name
    --> tests/tests.rs:1984:4
     |
1984 | fn test_dynamicRef_12() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_12`

warning: function `test_dynamicRef_13` should have a snake case name
    --> tests/tests.rs:1990:4
     |
1990 | fn test_dynamicRef_13() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_13`

warning: function `test_dynamicRef_14` should have a snake case name
    --> tests/tests.rs:1996:4
     |
1996 | fn test_dynamicRef_14() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_14`

warning: function `test_dynamicRef_15` should have a snake case name
    --> tests/tests.rs:2002:4
     |
2002 | fn test_dynamicRef_15() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_15`

warning: function `test_dynamicRef_16` should have a snake case name
    --> tests/tests.rs:2008:4
     |
2008 | fn test_dynamicRef_16() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_16`

warning: function `test_dynamicRef_17` should have a snake case name
    --> tests/tests.rs:2014:4
     |
2014 | fn test_dynamicRef_17() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_17`

warning: function `test_dynamicRef_18` should have a snake case name
    --> tests/tests.rs:2020:4
     |
2020 | fn test_dynamicRef_18() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_18`

warning: function `test_dynamicRef_19` should have a snake case name
    --> tests/tests.rs:2026:4
     |
2026 | fn test_dynamicRef_19() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_19`

warning: function `test_dynamicRef_20` should have a snake case name
    --> tests/tests.rs:2032:4
     |
2032 | fn test_dynamicRef_20() {
     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_dynamic_ref_20`

warning: `jspg` (test "tests") generated 132 warnings
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running tests/tests.rs (target/debug/deps/tests-0f6b1e496850f0af)

running 1 test

thread 'test_ref_39' (14864151) panicked at tests/tests.rs:1812:45:
called `Result::unwrap()` on an `Err` value: "[implicit keyword shadowing] Test 'child type overrides parent type' failed. Expected: true, Got: true. Errors: [Error { punc: None, code: \"STRICT_PROPERTY_VIOLATION\", message: \"Unexpected property 'age'\", details: ErrorDetails { path: \"/age\" } }]\n[implicit keyword shadowing] Test 'parent max age (20) is shadowed (replaced) by child definition' failed. Expected: true, Got: true. Errors: [Error { punc: None, code: \"STRICT_PROPERTY_VIOLATION\", message: \"Unexpected property 'age'\", details: ErrorDetails { path: \"/age\" } }]"
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
test test_ref_39 ... FAILED

failures:

failures:
    test_ref_39

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 338 filtered out; finished in 0.01s

error: test failed, to rerun pass `--test tests`