diff --git a/.agent/workflows/jspg.md b/.agent/workflows/jspg.md index b4c2676..55ad312 100644 --- a/.agent/workflows/jspg.md +++ b/.agent/workflows/jspg.md @@ -8,9 +8,11 @@ Read over this entire workflow and commit to every section of work in a task lis Please analyze the files and directories and do not use cat, find, or the terminal to discover or read in any of these files. Analyze every file mentioned. If a directory is mentioned or a /*, please analyze the directory, every single file at its root, and recursively analyze every subdirectory and every single file in every subdirectory to capture not just critical files, but the entirety of what is requested. I state again, DO NOT just review a cherry picking of files in any folder or wildcard specified. Review 100% of all files discovered recursively! -Section 1: Documentation +Section 1: Various Documentation -- GEMINI.md at the root +- GEMINI.md at the root (JSPG doc) +- api/punc/GEMINI.md +- api/punc/generator/GEMINI.md Section 2: Flow file for cmd interface @@ -22,7 +24,14 @@ Section 3: Source Section 4: Test Fixtures -- Just review some of the *.json files in tests/fixtures/* +Just review some of the *.json files in fixtures/ at the root + +- fixtures/allOf.json +- fixtures/ref.json +- fixtures/contains.json +- fixtures/queryer.json +- fixtures/merger.json +- fixtures/merge.json Section 5: Build @@ -36,14 +45,19 @@ Section 7: Some PUNC Syntax Now, review some punc type and enum source in the api project with api/ these files: -- punc/sql/tables.sql -- punc/sql/domains.sql -- punc/sql/indexes.sql -- punc/sql/functions/entity.sql -- punc/sql/functions/puncs.sql -- punc/sql/puncs/entity.sql -- punc/sql/puncs/persons.sql -- punc/sql/puncs/puncs.sql -- punc/sql/puncs/job.sql +- api/punc/sql/tables.sql +- api/punc/sql/domains.sql +- api/punc/sql/indexes.sql +- api/punc/sql/functions/entity.sql +- api/punc/sql/functions/puncs.sql +- api/punc/sql/puncs/entity.sql +- api/punc/sql/puncs/persons.sql +- api/punc/sql/puncs/puncs.sql +- api/punc/sql/puncs/job.sql +- api/contact/sql/tables.sql +- api/contact/sql/domains.sql +- api/contact/sql/indexes.sql +- api/contact/sql/domains.sql +- api/contact/sql/puncs/contacts.sql Now you are ready to help me work on this extension. \ No newline at end of file diff --git a/build.rs b/build.rs index e889c96..f334df1 100644 --- a/build.rs +++ b/build.rs @@ -63,6 +63,7 @@ fn main() { .unwrap() .as_array() .expect("Tests must be an array"); + let safe_filename = to_safe_identifier(file_name); for (t_idx, test) in tests.iter().enumerate() { let t_obj = test.as_object().expect("Test case must be an object"); if !t_obj.contains_key("description") { @@ -71,25 +72,24 @@ fn main() { file_name, i, t_idx ); } - } - // Use deterministic names: test_{filename}_{index} - let safe_filename = to_safe_identifier(file_name); - let fn_name = format!("test_{}_{}", safe_filename, i); + // Use deterministic names: test_{filename}_{suite_idx}_{test_idx} + let fn_name = format!("test_{}_{}_{}", safe_filename, i, t_idx); - // Write to src/tests/fixtures.rs (Std Test) - write!( - std_file, - r#" + // Write to src/tests/fixtures.rs (Std Test) + write!( + std_file, + r#" #[test] fn {}() {{ let path = format!("{{}}/fixtures/{}.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, {}).unwrap(); + crate::tests::runner::run_test_case(&path, {}, {}).unwrap(); }} "#, - fn_name, file_name, i - ) - .unwrap(); + fn_name, file_name, i, t_idx + ) + .unwrap(); + } } } } diff --git a/fixtures/merger.json b/fixtures/merger.json index 6f66c09..5e3e14e 100644 --- a/fixtures/merger.json +++ b/fixtures/merger.json @@ -137,13 +137,923 @@ "success": true, "sql": [ "SELECT to_jsonb(t1.*) || to_jsonb(t2.*) FROM agreego.\"simple_entity\" t1 LEFT JOIN agreego.\"entity\" t2 ON t2.id = t1.id WHERE t1.id = '123'", - "INSERT INTO agreego.\"simple_entity\" (\"id\", \"name\", \"type\") VALUES ('123', 'Jane', 'simple_entity')", "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', '123', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'simple_entity')", + "INSERT INTO agreego.\"simple_entity\" (\"id\", \"name\", \"type\") VALUES ('123', 'Jane', 'simple_entity')", "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"name\":\"Jane\",\"type\":\"simple_entity\"}', '123', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"id\":\"123\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"name\":\"Jane\",\"type\":\"simple_entity\"}}')" ] } } ] + }, + { + "description": "Hierarchical Lookups and Inserts", + "database": { + "puncs": [], + "enums": [], + "relations": [], + "types": [ + { + "name": "entity", + "schemas": [ + { + "$id": "entity", + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "type": { + "type": "string" + }, + "archived": { + "type": "boolean" + }, + "created_by": { + "type": "string" + }, + "modified_by": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "modified_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "type", + "created_by", + "created_at", + "modified_by", + "modified_at" + ] + } + ], + "hierarchy": [ + "entity" + ], + "fields": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": false, + "relationship": false + }, + { + "name": "organization", + "schemas": [ + { + "$id": "organization", + "$ref": "entity", + "properties": { + "name": { + "type": "string" + } + } + } + ], + "hierarchy": [ + "organization", + "entity" + ], + "fields": [ + "id", + "type", + "name", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "organization": [ + "id", + "type", + "name" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": true, + "relationship": false + }, + { + "name": "user", + "schemas": [ + { + "$id": "user", + "$ref": "organization", + "properties": {} + } + ], + "hierarchy": [ + "user", + "organization", + "entity" + ], + "fields": [ + "id", + "type", + "name", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "user": [ + "id", + "type" + ], + "organization": [ + "id", + "type", + "name" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": true, + "relationship": false + }, + { + "name": "person", + "schemas": [ + { + "$id": "person", + "$ref": "user", + "properties": { + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "date_of_birth": { + "type": "string" + }, + "pronouns": { + "type": "string" + }, + "contact_id": { + "type": "string" + } + } + } + ], + "hierarchy": [ + "person", + "user", + "organization", + "entity" + ], + "fields": [ + "id", + "type", + "first_name", + "last_name", + "date_of_birth", + "pronouns", + "contact_id", + "name", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "person": [ + "id", + "type", + "first_name", + "last_name", + "date_of_birth", + "pronouns", + "contact_id" + ], + "user": [ + "id", + "type" + ], + "organization": [ + "id", + "type", + "name" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [ + "first_name", + "last_name", + "date_of_birth", + "pronouns" + ], + "historical": true, + "relationship": false + }, + { + "name": "order", + "schemas": [ + { + "$id": "order", + "$ref": "entity", + "properties": { + "total": { + "type": "number" + }, + "customer_id": { + "type": "string" + } + } + } + ], + "hierarchy": [ + "order", + "entity" + ], + "fields": [ + "id", + "type", + "total", + "customer_id", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "order": [ + "id", + "type", + "total", + "customer_id" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [ + "id" + ], + "historical": true, + "relationship": false + }, + { + "name": "order_line", + "schemas": [ + { + "$id": "order_line", + "$ref": "entity", + "properties": { + "order_id": { + "type": "string" + }, + "product": { + "type": "string" + }, + "price": { + "type": "number" + } + } + } + ], + "hierarchy": [ + "order_line", + "entity" + ], + "fields": [ + "id", + "type", + "order_id", + "product", + "price", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "order_line": [ + "id", + "type", + "order_id", + "product", + "price" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": true, + "relationship": false + } + ] + }, + "tests": [ + { + "description": "Should query by ID if provided, rather than looking up by fields", + "action": "merge", + "data": { + "id": "123", + "type": "person", + "first_name": "John", + "last_name": "Doe", + "date_of_birth": "1990-01-01T00:00:00Z" + }, + "expect": { + "success": true, + "sql": [ + "SELECT to_jsonb(t1.*) || to_jsonb(t2.*) || to_jsonb(t3.*) || to_jsonb(t4.*) FROM agreego.\"person\" t1 LEFT JOIN agreego.\"user\" t2 ON t2.id = t1.id LEFT JOIN agreego.\"organization\" t3 ON t3.id = t1.id LEFT JOIN agreego.\"entity\" t4 ON t4.id = t1.id WHERE t1.id = '123'", + "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', '123', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'person')", + "INSERT INTO agreego.\"organization\" (\"id\", \"type\") VALUES ('123', 'person')", + "INSERT INTO agreego.\"user\" (\"id\", \"type\") VALUES ('123', 'person')", + "INSERT INTO agreego.\"person\" (\"date_of_birth\", \"first_name\", \"id\", \"last_name\", \"type\") VALUES ('1990-01-01T00:00:00Z', 'John', '123', 'Doe', 'person')", + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"date_of_birth\":\"1990-01-01T00:00:00Z\",\"first_name\":\"John\",\"last_name\":\"Doe\",\"type\":\"person\"}', '123', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", + "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"date_of_birth\":\"1990-01-01T00:00:00Z\",\"first_name\":\"John\",\"id\":\"123\",\"last_name\":\"Doe\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"type\":\"person\"}}')" + ] + } + }, + { + "description": "Should execute a lookup based on defined lookup_fields because no ID is provided", + "action": "merge", + "data": { + "type": "person", + "first_name": "John", + "last_name": "Doe", + "date_of_birth": "1990-01-01T00:00:00Z" + }, + "expect": { + "success": true, + "sql": [ + "SELECT to_jsonb(t1.*) || to_jsonb(t2.*) || to_jsonb(t3.*) || to_jsonb(t4.*) FROM agreego.\"person\" t1 LEFT JOIN agreego.\"user\" t2 ON t2.id = t1.id LEFT JOIN agreego.\"organization\" t3 ON t3.id = t1.id LEFT JOIN agreego.\"entity\" t4 ON t4.id = t1.id WHERE \"first_name\" = 'John' AND \"last_name\" = 'Doe' AND \"date_of_birth\" = '1990-01-01T00:00:00Z' AND \"pronouns\" IS NULL", + "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', '{{uuid:person_1}}', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'person')", + "INSERT INTO agreego.\"organization\" (\"id\", \"type\") VALUES ('{{uuid:person_1}}', 'person')", + "INSERT INTO agreego.\"user\" (\"id\", \"type\") VALUES ('{{uuid:person_1}}', 'person')", + "INSERT INTO agreego.\"person\" (\"date_of_birth\", \"first_name\", \"id\", \"last_name\", \"type\") VALUES ('1990-01-01T00:00:00Z', 'John', '{{uuid:person_1}}', 'Doe', 'person')", + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"date_of_birth\":\"1990-01-01T00:00:00Z\",\"first_name\":\"John\",\"last_name\":\"Doe\",\"type\":\"person\"}', '{{uuid:person_1}}', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", + "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"date_of_birth\":\"1990-01-01T00:00:00Z\",\"first_name\":\"John\",\"id\":\"{{uuid:person_1}}\",\"last_name\":\"Doe\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"type\":\"person\"}}')" + ] + } + }, + { + "description": "Should explicitly null out fields provided as empty strings", + "action": "merge", + "data": { + "id": "123", + "type": "person", + "first_name": "John", + "last_name": "Doe", + "date_of_birth": "1990-01-01T00:00:00Z", + "pronouns": "" + }, + "expect": { + "success": true, + "sql": [ + "SELECT to_jsonb(t1.*) || to_jsonb(t2.*) || to_jsonb(t3.*) || to_jsonb(t4.*) FROM agreego.\"person\" t1 LEFT JOIN agreego.\"user\" t2 ON t2.id = t1.id LEFT JOIN agreego.\"organization\" t3 ON t3.id = t1.id LEFT JOIN agreego.\"entity\" t4 ON t4.id = t1.id WHERE t1.id = '123'", + "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', '123', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'person')", + "INSERT INTO agreego.\"organization\" (\"id\", \"type\") VALUES ('123', 'person')", + "INSERT INTO agreego.\"user\" (\"id\", \"type\") VALUES ('123', 'person')", + "INSERT INTO agreego.\"person\" (\"date_of_birth\", \"first_name\", \"id\", \"last_name\", \"pronouns\", \"type\") VALUES ('1990-01-01T00:00:00Z', 'John', '123', 'Doe', NULL, 'person')", + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"date_of_birth\":\"1990-01-01T00:00:00Z\",\"first_name\":\"John\",\"last_name\":\"Doe\",\"pronouns\":\"\",\"type\":\"person\"}', '123', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", + "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"date_of_birth\":\"1990-01-01T00:00:00Z\",\"first_name\":\"John\",\"id\":\"123\",\"last_name\":\"Doe\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"pronouns\":\"\",\"type\":\"person\"}}')" + ] + } + } + ] + }, + { + "description": "Nested Relationship Mapping", + "database": { + "puncs": [], + "enums": [ + { + "id": "e-type-1", + "type": "relation_type", + "enum": "relation_type", + "values": [ + "foreign_key", + "polymorphic", + "graph" + ] + } + ], + "relations": [ + { + "id": "r-order-customer", + "type": "relation", + "constraint": "fk_order_customer", + "source_type": "order", + "source_columns": [ + "customer_id" + ], + "destination_type": "person", + "destination_columns": [ + "id" + ], + "prefix": "customer" + }, + { + "id": "r-order-lines", + "type": "relation", + "constraint": "fk_order_line_order", + "source_type": "order_line", + "source_columns": [ + "order_id" + ], + "destination_type": "order", + "destination_columns": [ + "id" + ], + "prefix": "lines" + } + ], + "types": [ + { + "name": "entity", + "schemas": [ + { + "$id": "entity", + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "type": { + "type": "string" + }, + "archived": { + "type": "boolean" + }, + "created_by": { + "type": "string" + }, + "modified_by": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "modified_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "type", + "created_by", + "created_at", + "modified_by", + "modified_at" + ] + } + ], + "hierarchy": [ + "entity" + ], + "fields": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": false, + "relationship": false + }, + { + "name": "organization", + "schemas": [ + { + "$id": "organization", + "$ref": "entity", + "properties": { + "name": { + "type": "string" + } + } + } + ], + "hierarchy": [ + "organization", + "entity" + ], + "fields": [ + "id", + "type", + "name", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "organization": [ + "id", + "type", + "name" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": true, + "relationship": false + }, + { + "name": "user", + "schemas": [ + { + "$id": "user", + "$ref": "organization", + "properties": {} + } + ], + "hierarchy": [ + "user", + "organization", + "entity" + ], + "fields": [ + "id", + "type", + "name", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "user": [ + "id", + "type" + ], + "organization": [ + "id", + "type", + "name" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": true, + "relationship": false + }, + { + "name": "person", + "schemas": [ + { + "$id": "person", + "$ref": "user", + "properties": { + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "date_of_birth": { + "type": "string" + }, + "pronouns": { + "type": "string" + }, + "contact_id": { + "type": "string" + } + } + } + ], + "hierarchy": [ + "person", + "user", + "organization", + "entity" + ], + "fields": [ + "id", + "type", + "first_name", + "last_name", + "date_of_birth", + "pronouns", + "contact_id", + "name", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "person": [ + "id", + "type", + "first_name", + "last_name", + "date_of_birth", + "pronouns", + "contact_id" + ], + "user": [ + "id", + "type" + ], + "organization": [ + "id", + "type", + "name" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [ + "first_name", + "last_name", + "date_of_birth", + "pronouns" + ], + "historical": true, + "relationship": false + }, + { + "name": "order", + "schemas": [ + { + "$id": "order", + "$ref": "entity", + "properties": { + "total": { + "type": "number" + }, + "customer_id": { + "type": "string" + } + } + } + ], + "hierarchy": [ + "order", + "entity" + ], + "fields": [ + "id", + "type", + "total", + "customer_id", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "order": [ + "id", + "type", + "total", + "customer_id" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [ + "id" + ], + "historical": true, + "relationship": false + }, + { + "name": "order_line", + "schemas": [ + { + "$id": "order_line", + "$ref": "entity", + "properties": { + "order_id": { + "type": "string" + }, + "product": { + "type": "string" + }, + "price": { + "type": "number" + } + } + } + ], + "hierarchy": [ + "order_line", + "entity" + ], + "fields": [ + "id", + "type", + "order_id", + "product", + "price", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ], + "grouped_fields": { + "order_line": [ + "id", + "type", + "order_id", + "product", + "price" + ], + "entity": [ + "id", + "type", + "created_at", + "created_by", + "modified_at", + "modified_by", + "archived" + ] + }, + "lookup_fields": [], + "historical": true, + "relationship": false + } + ] + }, + "tests": [ + { + "description": "Should execute a 1:1 nested relation and cascade child IDs to parent", + "action": "merge", + "data": { + "type": "order", + "total": 100.0, + "customer": { + "type": "person", + "first_name": "Bob", + "last_name": "Smith", + "date_of_birth": "2000-01-01" + } + }, + "expect": { + "success": true, + "sql": [ + "SELECT to_jsonb(t1.*) || to_jsonb(t2.*) FROM agreego.\"order\" t1 LEFT JOIN agreego.\"entity\" t2 ON t2.id = t1.id WHERE \"id\" IS NULL", + "SELECT to_jsonb(t1.*) || to_jsonb(t2.*) || to_jsonb(t3.*) || to_jsonb(t4.*) FROM agreego.\"person\" t1 LEFT JOIN agreego.\"user\" t2 ON t2.id = t1.id LEFT JOIN agreego.\"organization\" t3 ON t3.id = t1.id LEFT JOIN agreego.\"entity\" t4 ON t4.id = t1.id WHERE \"first_name\" = 'Bob' AND \"last_name\" = 'Smith' AND \"date_of_birth\" = '2000-01-01' AND \"pronouns\" IS NULL", + "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', '{{uuid:customer_id}}', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'person')", + "INSERT INTO agreego.\"organization\" (\"id\", \"type\") VALUES ('{{uuid:customer_id}}', 'person')", + "INSERT INTO agreego.\"user\" (\"id\", \"type\") VALUES ('{{uuid:customer_id}}', 'person')", + "INSERT INTO agreego.\"person\" (\"date_of_birth\", \"first_name\", \"id\", \"last_name\", \"type\") VALUES ('2000-01-01', 'Bob', '{{uuid:customer_id}}', 'Smith', 'person')", + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"date_of_birth\":\"2000-01-01\",\"first_name\":\"Bob\",\"last_name\":\"Smith\",\"type\":\"person\"}', '{{uuid:customer_id}}', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", + "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"date_of_birth\":\"2000-01-01\",\"first_name\":\"Bob\",\"id\":\"{{uuid:customer_id}}\",\"last_name\":\"Smith\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"type\":\"person\"}}')", + "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', '{{uuid:order_id}}', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'order')", + "INSERT INTO agreego.\"order\" (\"customer_id\", \"id\", \"total\", \"type\") VALUES ('{{uuid:customer_id}}', '{{uuid:order_id}}', 100, 'order')", + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"customer_id\":\"{{uuid:customer_id}}\",\"total\":100.0,\"type\":\"order\"}', '{{uuid:order_id}}', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", + "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"customer_id\":\"{{uuid:customer_id}}\",\"id\":\"{{uuid:order_id}}\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"total\":100.0,\"type\":\"order\"}}')" + ] + } + }, + { + "description": "Should execute a 1:N array relation mapping parent IDs to children", + "action": "merge", + "data": { + "id": "abc", + "type": "order", + "total": 99.0, + "lines": [ + { + "type": "order_line", + "product": "Widget", + "price": 99.0 + } + ] + }, + "expect": { + "success": true, + "sql": [ + "SELECT to_jsonb(t1.*) || to_jsonb(t2.*) FROM agreego.\"order\" t1 LEFT JOIN agreego.\"entity\" t2 ON t2.id = t1.id WHERE t1.id = 'abc'", + "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'abc', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'order')", + "INSERT INTO agreego.\"order\" (\"id\", \"total\", \"type\") VALUES ('abc', 99, 'order')", + "INSERT INTO agreego.\"entity\" (\"created_at\", \"created_by\", \"id\", \"modified_at\", \"modified_by\", \"type\") VALUES ('{{timestamp}}', '00000000-0000-0000-0000-000000000000', '{{uuid:line_id}}', '{{timestamp}}', '00000000-0000-0000-0000-000000000000', 'order_line')", + "INSERT INTO agreego.\"order_line\" (\"id\", \"order_id\", \"price\", \"product\", \"type\") VALUES ('{{uuid:line_id}}', 'abc', 99, 'Widget', 'order_line')", + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"order_id\":\"abc\",\"price\":99.0,\"product\":\"Widget\",\"type\":\"order_line\"}', '{{uuid:line_id}}', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", + "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"id\":\"{{uuid:line_id}}\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"order_id\":\"abc\",\"price\":99.0,\"product\":\"Widget\",\"type\":\"order_line\"}}')", + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ('{\"total\":99.0,\"type\":\"order\"}', 'abc', '{{uuid}}', 'create', '{{timestamp}}', '00000000-0000-0000-0000-000000000000')", + "SELECT pg_notify('entity', '{\"complete\":{\"created_at\":\"{{timestamp}}\",\"created_by\":\"00000000-0000-0000-0000-000000000000\",\"id\":\"abc\",\"modified_at\":\"{{timestamp}}\",\"modified_by\":\"00000000-0000-0000-0000-000000000000\",\"total\":99.0,\"type\":\"order\"}}')" + ] + } + } + ] } ] \ No newline at end of file diff --git a/src/database/executors/mock.rs b/src/database/executors/mock.rs index cec1de9..abf7d47 100644 --- a/src/database/executors/mock.rs +++ b/src/database/executors/mock.rs @@ -2,23 +2,38 @@ use crate::database::executors::DatabaseExecutor; use serde_json::Value; #[cfg(test)] -use std::sync::Mutex; +use std::cell::RefCell; #[cfg(test)] -pub struct MockExecutor { - pub query_responses: Mutex>>, - pub execute_responses: Mutex>>, - pub captured_queries: Mutex>, +pub struct MockState { + pub captured_queries: Vec, + pub query_responses: Vec>, + pub execute_responses: Vec>, } +#[cfg(test)] +impl MockState { + pub fn new() -> Self { + Self { + captured_queries: Default::default(), + query_responses: Default::default(), + execute_responses: Default::default(), + } + } +} + +#[cfg(test)] +thread_local! { + pub static MOCK_STATE: RefCell = RefCell::new(MockState::new()); +} + +#[cfg(test)] +pub struct MockExecutor {} + #[cfg(test)] impl MockExecutor { pub fn new() -> Self { - Self { - query_responses: Mutex::new(Vec::new()), - execute_responses: Mutex::new(Vec::new()), - captured_queries: Mutex::new(Vec::new()), - } + Self {} } } @@ -26,22 +41,26 @@ impl MockExecutor { impl DatabaseExecutor for MockExecutor { fn query(&self, sql: &str, _args: Option<&[Value]>) -> Result { println!("DEBUG SQL QUERY: {}", sql); - self.captured_queries.lock().unwrap().push(sql.to_string()); - let mut responses = self.query_responses.lock().unwrap(); - if responses.is_empty() { - return Ok(Value::Array(vec![])); - } - responses.remove(0) + MOCK_STATE.with(|state| { + let mut s = state.borrow_mut(); + s.captured_queries.push(sql.to_string()); + if s.query_responses.is_empty() { + return Ok(Value::Array(vec![])); + } + s.query_responses.remove(0) + }) } fn execute(&self, sql: &str, _args: Option<&[Value]>) -> Result<(), String> { println!("DEBUG SQL EXECUTE: {}", sql); - self.captured_queries.lock().unwrap().push(sql.to_string()); - let mut responses = self.execute_responses.lock().unwrap(); - if responses.is_empty() { - return Ok(()); - } - responses.remove(0) + MOCK_STATE.with(|state| { + let mut s = state.borrow_mut(); + s.captured_queries.push(sql.to_string()); + if s.execute_responses.is_empty() { + return Ok(()); + } + s.execute_responses.remove(0) + }) } fn auth_user_id(&self) -> Result { @@ -54,11 +73,16 @@ impl DatabaseExecutor for MockExecutor { #[cfg(test)] fn get_queries(&self) -> Vec { - self.captured_queries.lock().unwrap().clone() + MOCK_STATE.with(|state| state.borrow().captured_queries.clone()) } #[cfg(test)] fn reset_mocks(&self) { - self.captured_queries.lock().unwrap().clear(); + MOCK_STATE.with(|state| { + let mut s = state.borrow_mut(); + s.captured_queries.clear(); + s.query_responses.clear(); + s.execute_responses.clear(); + }); } } diff --git a/src/database/mod.rs b/src/database/mod.rs index 5331c02..3dbb099 100644 --- a/src/database/mod.rs +++ b/src/database/mod.rs @@ -76,8 +76,11 @@ impl Database { if let Some(arr) = val.get("relations").and_then(|v| v.as_array()) { for item in arr { - if let Ok(def) = serde_json::from_value::(item.clone()) { - db.relations.insert(def.constraint.clone(), def); + match serde_json::from_value::(item.clone()) { + Ok(def) => { + db.relations.insert(def.constraint.clone(), def); + } + Err(e) => println!("DATABASE RELATION PARSE FAILED: {:?}", e), } } } diff --git a/src/merger/mod.rs b/src/merger/mod.rs index 31d68ae..e488e77 100644 --- a/src/merger/mod.rs +++ b/src/merger/mod.rs @@ -4,7 +4,6 @@ pub mod cache; use crate::database::Database; - use serde_json::Value; use std::sync::Arc; @@ -23,7 +22,34 @@ impl Merger { pub fn merge(&self, data: Value) -> crate::drop::Drop { match self.merge_internal(data) { - Ok(val) => crate::drop::Drop::success_with_val(val), + Ok(val) => { + let stripped_val = match val { + Value::Object(mut map) => { + let mut out = serde_json::Map::new(); + if let Some(id) = map.remove("id") { + out.insert("id".to_string(), id); + } + Value::Object(out) + } + Value::Array(arr) => { + let mut out_arr = Vec::new(); + for item in arr { + if let Value::Object(mut map) = item { + let mut out = serde_json::Map::new(); + if let Some(id) = map.remove("id") { + out.insert("id".to_string(), id); + } + out_arr.push(Value::Object(out)); + } else { + out_arr.push(Value::Null); + } + } + Value::Array(out_arr) + } + other => other, + }; + crate::drop::Drop::success_with_val(stripped_val) + } Err(msg) => crate::drop::Drop::with_errors(vec![crate::drop::Error { code: "MERGE_FAILED".to_string(), message: msg, @@ -34,484 +60,331 @@ impl Merger { } } - /// Primary recursive entrypoint that separates Array lists from Object branches pub(crate) fn merge_internal(&self, data: Value) -> Result { - let result = match data { - Value::Array(items) => self.merge_array(items)?, - Value::Object(map) => self.merge_object(map)?, - // Nulls, Strings, Bools, Numbers at root are invalid merge payloads - _ => return Err("Invalid merge payload: root must be an Object or Array".to_string()), - }; - - Ok(match result { - Value::Object(mut map) => { - let mut out = serde_json::Map::new(); - if let Some(id) = map.remove("id") { - out.insert("id".to_string(), id); - } - Value::Object(out) - } - Value::Array(arr) => { - let mut out_arr = Vec::new(); - for item in arr { - if let Value::Object(mut map) = item { - let mut out = serde_json::Map::new(); - if let Some(id) = map.remove("id") { - out.insert("id".to_string(), id); - } - out_arr.push(Value::Object(out)); - } else { - out_arr.push(Value::Null); - } - } - Value::Array(out_arr) - } - other => other, - }) + match data { + Value::Array(items) => self.merge_array(items), + Value::Object(map) => self.merge_object(map), + _ => Err("Invalid merge payload: root must be an Object or Array".to_string()), + } } - /// Handles mapping over an array of entities, executing merge logic on each and returning the resolved list. fn merge_array(&self, items: Vec) -> Result { let mut resolved_items = Vec::new(); for item in items { - // Recursively evaluate each object in the array let resolved = self.merge_internal(item)?; resolved_items.push(resolved); } Ok(Value::Array(resolved_items)) } - /// Core processing algorithm for a single Entity Object dictionary. - fn merge_object(&self, mut obj: serde_json::Map) -> Result { - // Step 1: Ensure it has a `type` definition to proceed + fn merge_object(&self, obj: serde_json::Map) -> Result { let type_name = match obj.get("type").and_then(|v| v.as_str()) { Some(t) => t.to_string(), None => return Err("Missing required 'type' field on object".to_string()), }; - // Step 2: Extract Type mapping from the Engine let type_def = match self.db.types.get(&type_name) { Some(t) => t, None => return Err(format!("Unknown entity type: {}", type_name)), }; - // Step 3 & 4: (Pre/Post Staging based on `relationship` flag) - if type_def.relationship { - // Relationships: process children FIRST (Post-Staging) - self.process_children(&mut obj, type_def)?; - Ok(Value::Object(self.stage_entity(obj)?)) - } else { - // Entities: process core FIRST (Pre-Staging) - let mut staged_obj_map = self.stage_entity(obj)?; - self.process_children(&mut staged_obj_map, type_def)?; - Ok(Value::Object(staged_obj_map)) - } - } + // 1. Segment the entity: fields in type_def.fields are database fields, others are relationships + let mut entity_fields = serde_json::Map::new(); + let mut entity_objects = serde_json::Map::new(); + let mut entity_arrays = serde_json::Map::new(); - /// Iterates values of `obj`, if they are structural (Array/Object), executes `self.merge()` on them. - /// Uses the `Database` registry to find FK relations and apply the IDs upstream/downstream appropriately. - fn process_children( - &self, - obj: &mut serde_json::Map, - type_def: &crate::database::r#type::Type, - ) -> Result<(), String> { - let keys: Vec = obj.keys().cloned().collect(); - - for key in keys { - // Temporarily extract value to process without borrowing Map mutably - let val = match obj.remove(&key) { - Some(v) => v, - None => continue, + for (k, v) in obj { + let is_field = type_def.fields.contains(&k) || k == "created"; + let typeof_v = match &v { + Value::Object(_) => "object", + Value::Array(_) => "array", + _ => "other", }; - if val.is_object() || val.is_array() { - // Pre-Process: Propagate parent data to children BEFORE recursing and applying relations - let mut child_val = val; - let mut relation_info = None; - - // Try to peek at the child type for relational mapping - let peek_obj = match &child_val { - Value::Object(m) => Some(m), - Value::Array(arr) if !arr.is_empty() => arr[0].as_object(), - _ => None, - }; - - if let Some(child_map) = peek_obj { - if let Ok(Some(relation)) = self.get_entity_relation(obj, type_def, child_map, &key) { - let child_type_name = child_map.get("type").and_then(|v| v.as_str()).unwrap_or(""); - if let Some(c_type) = self.db.types.get(child_type_name) { - let parent_is_source = type_def.hierarchy.contains(&relation.source_type); - let child_is_source = c_type.hierarchy.contains(&relation.source_type); - relation_info = Some((relation, parent_is_source, child_is_source)); - } - } - } - - // Apply pre-merge mutations mapping IDs - if let Some((relation, _parent_is_source, child_is_source)) = relation_info.as_ref() { - match &mut child_val { - Value::Object(child_map) => { - // Cascade Organization ID - if !child_map.contains_key("organization_id") { - if let Some(org_id) = obj.get("organization_id") { - child_map.insert("organization_id".to_string(), org_id.clone()); - } - } - // If child owns FK, parent provides it - if *child_is_source { - Self::apply_entity_relation( - child_map, - &relation.source_columns, - &relation.destination_columns, - obj, - ); - } - } - Value::Array(items) => { - for item in items.iter_mut() { - if let Value::Object(child_map) = item { - if !child_map.contains_key("organization_id") { - if let Some(org_id) = obj.get("organization_id") { - child_map.insert("organization_id".to_string(), org_id.clone()); - } - } - if *child_is_source { - Self::apply_entity_relation( - child_map, - &relation.source_columns, - &relation.destination_columns, - obj, - ); - } - } - } - } - _ => {} - } - } - - // RECURSE: Merge the modified children - let merged_val = self.merge_internal(child_val)?; - - // Post-Process: Apply relations upwards if parent owns the FK - if let Some((relation, parent_is_source, _child_is_source)) = relation_info { - if parent_is_source { - match &merged_val { - Value::Object(merged_child_map) => { - Self::apply_entity_relation( - obj, - &relation.source_columns, - &relation.destination_columns, - merged_child_map, - ); - } - Value::Array(items) if !items.is_empty() => { - if let Value::Object(merged_child_map) = &items[0] { - Self::apply_entity_relation( - obj, - &relation.source_columns, - &relation.destination_columns, - merged_child_map, - ); - } - } - _ => {} - } - } - } - - obj.insert(key, merged_val); - } else { - obj.insert(key, val); + if is_field { + entity_fields.insert(k, v); + } else if typeof_v == "object" { + entity_objects.insert(k, v); + } else if typeof_v == "array" { + entity_arrays.insert(k, v); } } - Ok(()) + + let user_id = self.db.auth_user_id()?; + let timestamp = self.db.timestamp()?; + + let mut entity_change_kind = None; + let mut entity_fetched = None; + + // 2. Pre-stage the entity (for non-relationships) + if !type_def.relationship { + let (fields, kind, fetched) = + self.stage_entity(entity_fields.clone(), type_def, &user_id, ×tamp)?; + entity_fields = fields; + entity_change_kind = kind; + entity_fetched = fetched; + } + + let mut entity_response = serde_json::Map::new(); + + // 3. Handle related objects + for (relation_name, relative_val) in entity_objects { + let mut relative = match relative_val { + Value::Object(m) => m, + _ => continue, + }; + + let relative_relation = self.get_entity_relation(type_def, &relative, &relation_name)?; + + if let Some(relation) = relative_relation { + let parent_is_source = type_def.hierarchy.contains(&relation.source_type); + + if parent_is_source { + // Parent holds FK to Child. Child MUST be generated FIRST. + if !relative.contains_key("organization_id") { + if let Some(org_id) = entity_fields.get("organization_id") { + relative.insert("organization_id".to_string(), org_id.clone()); + } + } + + let merged_relative = match self.merge_internal(Value::Object(relative))? { + Value::Object(m) => m, + _ => continue, + }; + + Self::apply_entity_relation( + &mut entity_fields, + &relation.source_columns, + &relation.destination_columns, + &merged_relative, + ); + entity_response.insert(relation_name, Value::Object(merged_relative)); + } else { + // Child holds FK back to Parent. + if !relative.contains_key("organization_id") { + if let Some(org_id) = entity_fields.get("organization_id") { + relative.insert("organization_id".to_string(), org_id.clone()); + } + } + + Self::apply_entity_relation( + &mut relative, + &relation.source_columns, + &relation.destination_columns, + &entity_fields, + ); + + let merged_relative = match self.merge_internal(Value::Object(relative))? { + Value::Object(m) => m, + _ => continue, + }; + + entity_response.insert(relation_name, Value::Object(merged_relative)); + } + } + } + + // 4. Post-stage the entity (for relationships) + if type_def.relationship { + let (fields, kind, fetched) = + self.stage_entity(entity_fields.clone(), type_def, &user_id, ×tamp)?; + entity_fields = fields; + entity_change_kind = kind; + entity_fetched = fetched; + } + + // 5. Process the main entity fields + self.merge_entity_fields( + entity_change_kind.as_deref().unwrap_or(""), + &type_name, + type_def, + &entity_fields, + entity_fetched.as_ref(), + )?; + + // Add main entity fields to response + for (k, v) in &entity_fields { + entity_response.insert(k.clone(), v.clone()); + } + + // 6. Handle related arrays + for (relation_name, relative_val) in entity_arrays { + let relative_arr = match relative_val { + Value::Array(a) => a, + _ => continue, + }; + + if relative_arr.is_empty() { + continue; + } + + let first_relative = match &relative_arr[0] { + Value::Object(m) => m, + _ => continue, + }; + + let relative_relation = self.get_entity_relation(type_def, first_relative, &relation_name)?; + + if let Some(relation) = relative_relation { + let mut relative_responses = Vec::new(); + for relative_item_val in relative_arr { + if let Value::Object(mut relative_item) = relative_item_val { + if !relative_item.contains_key("organization_id") { + if let Some(org_id) = entity_fields.get("organization_id") { + relative_item.insert("organization_id".to_string(), org_id.clone()); + } + } + + Self::apply_entity_relation( + &mut relative_item, + &relation.source_columns, + &relation.destination_columns, + &entity_fields, + ); + + let merged_relative = match self.merge_internal(Value::Object(relative_item))? { + Value::Object(m) => m, + _ => continue, + }; + + relative_responses.push(Value::Object(merged_relative)); + } + } + entity_response.insert(relation_name, Value::Array(relative_responses)); + } + } + + // 7. Perform change tracking + self.merge_entity_change( + &entity_fields, + entity_fetched.as_ref(), + entity_change_kind.as_deref(), + &user_id, + ×tamp, + )?; + + // Produce the full tree response + let mut final_response = serde_json::Map::new(); + if let Some(fetched) = entity_fetched { + for (k, v) in fetched { + final_response.insert(k, v); + } + } + for (k, v) in entity_response { + final_response.insert(k, v); + } + + Ok(Value::Object(final_response)) } - /// Evaluates `lk_` structures, fetches existing rows via SPI, computes `compare_entities` diff, - /// executes UPDATE/INSERT SPI, and handles `agreego.change` auditing. fn stage_entity( &self, - mut obj: serde_json::Map, - ) -> Result, String> { - let type_name = obj - .get("type") - .and_then(|v| v.as_str()) - .unwrap() - .to_string(); - let type_def = self.db.types.get(&type_name).unwrap(); + mut entity_fields: serde_json::Map, + type_def: &crate::database::r#type::Type, + user_id: &str, + timestamp: &str, + ) -> Result< + ( + serde_json::Map, + Option, + Option>, + ), + String, + > { + let type_name = type_def.name.as_str(); - // 1. Fetch Existing Entity - let existing_entity = self.fetch_entity(&obj, type_def)?; + let entity_fetched = self.fetch_entity(&entity_fields, type_def)?; - // 2. Identify System Keys we don't want to diff let system_keys = vec![ "id".to_string(), "type".to_string(), - "organization_id".to_string(), "created_by".to_string(), "modified_by".to_string(), "created_at".to_string(), "modified_at".to_string(), ]; - // 3. Compare entities to find exact changes let changes = self.compare_entities( - existing_entity.as_ref(), - &obj, + entity_fetched.as_ref(), + &entity_fields, &type_def.fields, &system_keys, ); - // 4. If no changes and an entity existed, we skip - let is_update = existing_entity.is_some(); - if is_update && changes.is_empty() { - return Ok(obj); - } + let mut entity_change_kind = None; - // 5. Apply correct system fields - let user_id = self.db.auth_user_id()?; - let timestamp = self.db.timestamp()?; - - let entity_change_kind = if !is_update { - if !obj.contains_key("id") { - use uuid::Uuid; - obj.insert("id".to_string(), Value::String(Uuid::new_v4().to_string())); - } - obj.insert("created_by".to_string(), Value::String(user_id.clone())); - obj.insert("created_at".to_string(), Value::String(timestamp.clone())); - obj.insert("modified_by".to_string(), Value::String(user_id.clone())); - obj.insert("modified_at".to_string(), Value::String(timestamp.clone())); - "create" - } else { - obj.insert("modified_by".to_string(), Value::String(user_id.clone())); - obj.insert("modified_at".to_string(), Value::String(timestamp.clone())); - "update" - }; - - // 6. Execute SQL Merges - self.merge_entity_fields(is_update, &type_name, type_def, &changes, &obj)?; - - // 7. Fire agreego.change - let mut complete = obj.clone(); - if is_update { - // overlay on top of existing for complete state - if let Some(mut existing) = existing_entity { - for (k, v) in &obj { - existing.insert(k.clone(), v.clone()); - } - complete = existing; - } - } - - let mut notification = serde_json::Map::new(); - notification.insert("complete".to_string(), Value::Object(complete.clone())); - - let changes_val = if !is_update { - let mut c = changes.clone(); - c.insert("type".to_string(), Value::String(type_name.clone())); - Value::Object(c) - } else { - notification.insert("changes".to_string(), Value::Object(changes.clone())); - Value::Object(changes.clone()) - }; - - let change_sql = format!( - "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ({}, {}, {}, {}, {}, {})", - Self::quote_literal(&changes_val), - Self::quote_literal(obj.get("id").unwrap()), - Self::quote_literal(&Value::String(uuid::Uuid::new_v4().to_string())), - Self::quote_literal(&Value::String(entity_change_kind.to_string())), - Self::quote_literal(&Value::String(timestamp.clone())), - Self::quote_literal(&Value::String(user_id.clone())) - ); - - let notification_json = Value::Object(notification); - let notify_sql = format!( - "SELECT pg_notify('entity', {})", - Self::quote_literal(&Value::String(notification_json.to_string())) - ); - - self - .db - .execute(&change_sql, None) - .map_err(|e| format!("Executor Error in change: {:?}", e))?; - self - .db - .execute(¬ify_sql, None) - .map_err(|e| format!("Executor Error in notify: {:?}", e))?; - - Ok(obj) - } - - /// Exact replica of `agreego.compare_entities`. Takes a fetched `old` entity from the DB (if any), - /// the `new_fields` from the JSON payload, the `fields` defined on the `Type` hierarchy, and a list of `system_keys`. - /// Returns a clean JSON object containing ONLY the modified keys, or an empty map if No-Op. - fn compare_entities( - &self, - fetched_entity: Option<&serde_json::Map>, - new_fields: &serde_json::Map, - type_fields: &[String], - system_keys: &[String], - ) -> serde_json::Map { - let mut changes = serde_json::Map::new(); - - for (key, new_val) in new_fields { - // 1. Skip if key is not part of the Type's total field schema mapping - if !type_fields.contains(key) { - continue; - } - // 2. Skip strictly managed system audit keys - if system_keys.contains(key) { - continue; - } - - match fetched_entity { - // 3a. If no old entity, every valid field is a new "change" - None => { - changes.insert(key.clone(), new_val.clone()); - } - // 3b. If old entity exists, strictly compare the values - Some(old_map) => { - let old_val = old_map.get(key).unwrap_or(&Value::Null); - if new_val != old_val { - changes.insert(key.clone(), new_val.clone()); - } - } - } - } - - changes - } - - /// Exact replica of `agreego.reduce_entity_relations`. Resolves Ambiguous Graph paths - /// down to a single distinct FK relationship path based on prefix rules. - fn reduce_entity_relations( - &self, - mut matching_relations: Vec, - relative: &serde_json::Map, - relation_name: &str, - ) -> Result, String> { - // 0 or 1 relations is an immediate fast-path resolution - if matching_relations.is_empty() { - return Ok(None); - } - if matching_relations.len() == 1 { - return Ok(Some(matching_relations.pop().unwrap())); - } - - // Step 1: Check for exact prefix match with the relation_name pointer - let exact_match: Vec<_> = matching_relations - .iter() - .filter(|r| r.prefix.as_deref() == Some(relation_name)) - .cloned() - .collect(); - if exact_match.len() == 1 { - return Ok(Some(exact_match.into_iter().next().unwrap())); - } - - // Step 2: Inverse filter - Remove any relations where their configured prefix IS found - // inside the actual payload data on `relative` - matching_relations.retain(|r| { - if let Some(prefix) = &r.prefix { - // If the prefix exists as a key in the relative JSON payload, we KEEP iter - // (Wait, actually the SQL is `WHERE NOT EXISTS (select mr.prefix where relative ? mr.prefix)` - // Translating: Keep relation R if its prefix is NOT matched in the payload - !relative.contains_key(prefix) + if entity_fetched.is_none() { + let entity_id = entity_fields + .get("id") + .and_then(|v| v.as_str()) + .unwrap_or(""); + let id_val = if entity_id.is_empty() { + Value::String(uuid::Uuid::new_v4().to_string()) } else { - true // No prefix means we keep it by default - } - }); + Value::String(entity_id.to_string()) + }; - if matching_relations.len() == 1 { - Ok(Some(matching_relations.pop().unwrap())) + entity_change_kind = Some("create".to_string()); + + let mut new_fields = changes.clone(); + new_fields.insert("id".to_string(), id_val); + new_fields.insert("type".to_string(), Value::String(type_name.to_string())); + new_fields.insert("created_by".to_string(), Value::String(user_id.to_string())); + new_fields.insert( + "created_at".to_string(), + Value::String(timestamp.to_string()), + ); + new_fields.insert( + "modified_by".to_string(), + Value::String(user_id.to_string()), + ); + new_fields.insert( + "modified_at".to_string(), + Value::String(timestamp.to_string()), + ); + + entity_fields = new_fields; + } else if changes.is_empty() { + let mut new_fields = serde_json::Map::new(); + new_fields.insert( + "id".to_string(), + entity_fetched.as_ref().unwrap().get("id").unwrap().clone(), + ); + new_fields.insert("type".to_string(), Value::String(type_name.to_string())); + + entity_fields = new_fields; } else { - let constraints: Vec<_> = matching_relations - .iter() - .map(|r| r.constraint.clone()) - .collect(); - Err(format!( - "AMBIGUOUS_TYPE_RELATIONS: Could not reduce ambiguous type relations: {}", - constraints.join(", ") - )) + let is_archived = changes + .get("archived") + .and_then(|v| v.as_bool()) + .unwrap_or(false); + entity_change_kind = if is_archived { + Some("delete".to_string()) + } else { + Some("update".to_string()) + }; + + let mut new_fields = changes.clone(); + new_fields.insert( + "id".to_string(), + entity_fetched.as_ref().unwrap().get("id").unwrap().clone(), + ); + new_fields.insert("type".to_string(), Value::String(type_name.to_string())); + new_fields.insert( + "modified_by".to_string(), + Value::String(user_id.to_string()), + ); + new_fields.insert( + "modified_at".to_string(), + Value::String(timestamp.to_string()), + ); + + entity_fields = new_fields; } + + Ok((entity_fields, entity_change_kind, entity_fetched)) } - /// Exact replica of `agreego.get_entity_relation`. Given two entities (`entity` and `relative`) and the JSON key linking them, - /// it searches the Database graphs for a concrete FK constraint. - fn get_entity_relation( - &self, - _entity: &serde_json::Map, - entity_type: &crate::database::r#type::Type, - relative: &serde_json::Map, - relation_name: &str, - ) -> Result, String> { - let relative_type_name = relative.get("type").and_then(|v| v.as_str()).unwrap_or(""); - let relative_type = match self.db.types.get(relative_type_name) { - Some(t) => t, - None => return Ok(None), - }; - - let mut relative_relations: Vec = Vec::new(); - - // 1. Look for direct relationships first - for r in self.db.relations.values() { - if r.source_type != "entity" && r.destination_type != "entity" { - let condition1 = relative_type.hierarchy.contains(&r.source_type) - && entity_type.hierarchy.contains(&r.destination_type); - let condition2 = entity_type.hierarchy.contains(&r.source_type) - && relative_type.hierarchy.contains(&r.destination_type); - - if condition1 || condition2 { - relative_relations.push(r.clone()); - } - } - } - - let mut relative_relation = - self.reduce_entity_relations(relative_relations, relative, relation_name)?; - - // 2. Look for polymorphic relationships if no direct relationship is found - if relative_relation.is_none() { - let mut poly_relations: Vec = Vec::new(); - for r in self.db.relations.values() { - if r.destination_type == "entity" { - let condition1 = relative_type.hierarchy.contains(&r.source_type); - let condition2 = entity_type.hierarchy.contains(&r.source_type); - - if condition1 || condition2 { - poly_relations.push(r.clone()); - } - } - } - relative_relation = self.reduce_entity_relations(poly_relations, relative, relation_name)?; - } - - Ok(relative_relation) - } - - /// Exact replica of `agreego.apply_entity_relation`. Syncs FK column values from the destination to the source. - fn apply_entity_relation( - source_entity: &mut serde_json::Map, - source_columns: &[String], - destination_columns: &[String], - destination_entity: &serde_json::Map, - ) { - if source_columns.len() != destination_columns.len() { - // In theory, validation should prevent this, but fail gracefully/ignore if lengths diverge. - return; - } - for i in 0..source_columns.len() { - let dest_val = destination_entity - .get(&destination_columns[i]) - .unwrap_or(&Value::Null) - .clone(); - source_entity.insert(source_columns[i].clone(), dest_val); - } - } - - /// Exact replica of `agreego.fetch_entity`. Dynamically constructs a `SELECT to_jsonb(t1.*) || to_jsonb(t2.*)` - /// based on the Type hierarchy and available `id` or `lookup_fields` presence. fn fetch_entity( &self, entity_fields: &serde_json::Map, @@ -520,21 +393,15 @@ impl Merger { let id_val = entity_fields.get("id"); let entity_type_name = entity_type.name.as_str(); - // Check if all required lookup keys are PRESENT (value can be anything, including NULL) - let lookup_complete = if entity_type.lookup_fields.is_empty() { - false - } else { - entity_type - .lookup_fields - .iter() - .all(|f| entity_fields.contains_key(f)) - }; + let mut lookup_complete = false; + if !entity_type.lookup_fields.is_empty() { + lookup_complete = true; + } if id_val.is_none() && !lookup_complete { return Ok(None); } - // Build or Retrieve Cached Select/Join clauses let fetch_sql_template = if let Some(cached) = self.cache.get(entity_type_name) { cached } else { @@ -557,15 +424,11 @@ impl Merger { template }; - // Build WHERE Clauses - let mut id_condition = None; - if let Some(id) = id_val { - id_condition = Some(format!("t1.id = {}", Self::quote_literal(id))); - } - - let mut lookup_condition = None; - if lookup_complete { + let where_clause = if let Some(id) = id_val { + format!("WHERE t1.id = {}", Self::quote_literal(id)) + } else if lookup_complete { let mut lookup_predicates = Vec::new(); + for column in &entity_type.lookup_fields { let val = entity_fields.get(column).unwrap_or(&Value::Null); if column == "type" { @@ -578,22 +441,14 @@ impl Merger { } } } - lookup_condition = Some(lookup_predicates.join(" AND ")); - } - - // Determine final WHERE clause based on available conditions - let where_clause = match (id_condition, lookup_condition) { - (Some(id_cond), Some(lookup_cond)) => format!("WHERE ({}) OR ({})", id_cond, lookup_cond), - (Some(id_cond), None) => format!("WHERE {}", id_cond), - (None, Some(lookup_cond)) => format!("WHERE {}", lookup_cond), - (None, None) => return Ok(None), + format!("WHERE {}", lookup_predicates.join(" AND ")) + } else { + return Ok(None); }; - // Construct Final Query - let fetch_sql = format!("{} {}", fetch_sql_template, where_clause); + let final_sql = format!("{} {}", fetch_sql_template, where_clause); - // Execute and Return Result via Database Executor - let fetched = match self.db.query(&fetch_sql, None) { + let fetched = match self.db.query(&final_sql, None) { Ok(Value::Array(table)) => { if table.len() > 1 { Err(format!( @@ -606,34 +461,30 @@ impl Merger { let row = table.first().unwrap(); match row { Value::Object(map) => Ok(Some(map.clone())), - other => Err(format!( - "Expected fetch_entity to return JSON object, got: {:?}", - other - )), + other => Err(format!("Expected JSON object, got: {:?}", other)), } } } - Ok(other) => Err(format!( - "Expected array from query in fetch_entity, got: {:?}", - other - )), + Ok(_) => Err("Expected array from query in fetch_entity".to_string()), Err(e) => Err(format!("SPI error in fetch_entity: {:?}", e)), }?; Ok(fetched) } - /// Exact replica of `agreego.merge_entity_fields`. Issues an INSERT or UPDATE per table - /// in the Type's hierarchy, filtering out keys that don't belong to the specific table block. fn merge_entity_fields( &self, - is_update: bool, + change_kind: &str, entity_type_name: &str, entity_type: &crate::database::r#type::Type, - changes: &serde_json::Map, - full_entity: &serde_json::Map, + entity_fields: &serde_json::Map, + _entity_fetched: Option<&serde_json::Map>, ) -> Result<(), String> { - let id_str = match full_entity.get("id").and_then(|v| v.as_str()) { + if change_kind.is_empty() { + return Ok(()); + } + + let id_str = match entity_fields.get("id").and_then(|v| v.as_str()) { Some(id) => id, None => return Err("Missing 'id' for merge execution".to_string()), }; @@ -648,9 +499,13 @@ impl Merger { } }; - for table_name in &entity_type.hierarchy { - // get the fields for this specific table (from grouped_fields) - let table_fields = match grouped_fields.get(table_name).and_then(|v| v.as_array()) { + let mut execute_order: Vec = entity_type.hierarchy.clone(); + if change_kind == "create" { + execute_order.reverse(); + } + + for table_name in execute_order { + let table_fields = match grouped_fields.get(&table_name).and_then(|v| v.as_array()) { Some(arr) => arr .iter() .filter_map(|v| v.as_str().map(|s| s.to_string())) @@ -658,57 +513,38 @@ impl Merger { None => continue, }; - let mut my_changes = Vec::new(); - for field in &table_fields { - if changes.contains_key(field) || (!is_update && full_entity.contains_key(field)) { - // For inserts we want all provided fields. For updates we only want changes. - my_changes.push(field.clone()); + let mut entity_pairs = serde_json::Map::new(); + for (k, v) in entity_fields { + if table_fields.contains(k) { + entity_pairs.insert(k.clone(), v.clone()); } } - my_changes.sort(); + if change_kind == "create" { + if !entity_pairs.contains_key("id") && table_fields.contains(&"id".to_string()) { + entity_pairs.insert("id".to_string(), Value::String(id_str.to_string())); + } + if !entity_pairs.contains_key("type") && table_fields.contains(&"type".to_string()) { + entity_pairs.insert( + "type".to_string(), + Value::String(entity_type_name.to_string()), + ); + } - if is_update { - if my_changes.is_empty() { - continue; - } - let mut set_clauses = Vec::new(); - for field in &my_changes { - let val = changes.get(field).unwrap(); - set_clauses.push(format!("\"{}\" = {}", field, Self::quote_literal(val))); - } - let sql = format!( - "UPDATE agreego.\"{}\" SET {} WHERE id = {}", - table_name, - set_clauses.join(", "), - Self::quote_literal(&Value::String(id_str.to_string())) - ); - self - .db - .execute(&sql, None) - .map_err(|e| format!("SPI Error in UPDATE: {:?}", e))?; - } else { - // INSERT let mut columns = Vec::new(); let mut values = Vec::new(); - for field in &my_changes { - columns.push(format!("\"{}\"", field)); - let val = full_entity.get(field).unwrap(); - values.push(Self::quote_literal(val)); - } + let mut sorted_keys: Vec<_> = entity_pairs.keys().cloned().collect(); + sorted_keys.sort(); - // Ensure 'id' and 'type' are present if required by this specific table schema chunk - if !columns.contains(&"\"id\"".to_string()) && table_fields.contains(&"id".to_string()) { - columns.push("\"id\"".to_string()); - values.push(Self::quote_literal(&Value::String(id_str.to_string()))); - } - if !columns.contains(&"\"type\"".to_string()) && table_fields.contains(&"type".to_string()) - { - columns.push("\"type\"".to_string()); - values.push(Self::quote_literal(&Value::String( - entity_type_name.to_string(), - ))); + for key in &sorted_keys { + columns.push(format!("\"{}\"", key)); + let val = entity_pairs.get(key).unwrap(); + if val.as_str() == Some("") { + values.push("NULL".to_string()); + } else { + values.push(Self::quote_literal(val)); + } } if columns.is_empty() { @@ -725,12 +561,284 @@ impl Merger { .db .execute(&sql, None) .map_err(|e| format!("SPI Error in INSERT: {:?}", e))?; + } else if change_kind == "update" || change_kind == "delete" { + entity_pairs.remove("id"); + entity_pairs.remove("type"); + + if entity_pairs.is_empty() { + continue; + } + + let mut set_clauses = Vec::new(); + let mut sorted_keys: Vec<_> = entity_pairs.keys().cloned().collect(); + sorted_keys.sort(); + + for key in &sorted_keys { + let val = entity_pairs.get(key).unwrap(); + if val.as_str() == Some("") { + set_clauses.push(format!("\"{}\" = NULL", key)); + } else { + set_clauses.push(format!("\"{}\" = {}", key, Self::quote_literal(val))); + } + } + + let sql = format!( + "UPDATE agreego.\"{}\" SET {} WHERE id = {}", + table_name, + set_clauses.join(", "), + Self::quote_literal(&Value::String(id_str.to_string())) + ); + self + .db + .execute(&sql, None) + .map_err(|e| format!("SPI Error in UPDATE: {:?}", e))?; } } + Ok(()) } - /// Helper to emulate Postgres `quote_literal` + fn merge_entity_change( + &self, + entity_fields: &serde_json::Map, + entity_fetched: Option<&serde_json::Map>, + entity_change_kind: Option<&str>, + user_id: &str, + timestamp: &str, + ) -> Result<(), String> { + let change_kind = match entity_change_kind { + Some(k) => k, + None => return Ok(()), + }; + + let id_str = entity_fields.get("id").unwrap(); + let type_name = entity_fields.get("type").unwrap(); + + let mut changes = serde_json::Map::new(); + let is_update = change_kind == "update" || change_kind == "delete"; + + if !is_update { + let system_keys = vec![ + "id".to_string(), + "created_by".to_string(), + "modified_by".to_string(), + "created_at".to_string(), + "modified_at".to_string(), + ]; + for (k, v) in entity_fields { + if !system_keys.contains(k) { + changes.insert(k.clone(), v.clone()); + } + } + } else { + let system_keys = vec![ + "id".to_string(), + "type".to_string(), + "created_by".to_string(), + "modified_by".to_string(), + "created_at".to_string(), + "modified_at".to_string(), + ]; + for (k, v) in entity_fields { + if !system_keys.contains(k) { + if let Some(fetched) = entity_fetched { + let old_val = fetched.get(k).unwrap_or(&Value::Null); + if v != old_val { + changes.insert(k.clone(), v.clone()); + } + } + } + } + changes.insert("type".to_string(), type_name.clone()); + } + + let mut complete = entity_fields.clone(); + if is_update { + if let Some(fetched) = entity_fetched { + let mut temp = fetched.clone(); + for (k, v) in entity_fields { + temp.insert(k.clone(), v.clone()); + } + complete = temp; + } + } + + let mut notification = serde_json::Map::new(); + notification.insert("complete".to_string(), Value::Object(complete)); + if is_update { + notification.insert("changes".to_string(), Value::Object(changes.clone())); + } + + let change_sql = format!( + "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ({}, {}, {}, {}, {}, {})", + Self::quote_literal(&Value::Object(changes)), + Self::quote_literal(id_str), + Self::quote_literal(&Value::String(uuid::Uuid::new_v4().to_string())), + Self::quote_literal(&Value::String(change_kind.to_string())), + Self::quote_literal(&Value::String(timestamp.to_string())), + Self::quote_literal(&Value::String(user_id.to_string())) + ); + + let notify_sql = format!( + "SELECT pg_notify('entity', {})", + Self::quote_literal(&Value::String(Value::Object(notification).to_string())) + ); + + self + .db + .execute(&change_sql, None) + .map_err(|e| format!("Executor Error in change: {:?}", e))?; + self + .db + .execute(¬ify_sql, None) + .map_err(|e| format!("Executor Error in notify: {:?}", e))?; + + Ok(()) + } + + fn compare_entities( + &self, + fetched_entity: Option<&serde_json::Map>, + new_fields: &serde_json::Map, + type_fields: &[String], + system_keys: &[String], + ) -> serde_json::Map { + let mut changes = serde_json::Map::new(); + + if fetched_entity.is_none() { + for (k, v) in new_fields { + if type_fields.contains(k) && !system_keys.contains(k) { + changes.insert(k.clone(), v.clone()); + } + } + return changes; + } + + let old_map = fetched_entity.unwrap(); + + for (k, v) in new_fields { + if type_fields.contains(k) && !system_keys.contains(k) { + let old_val = old_map.get(k).unwrap_or(&Value::Null); + if v != old_val { + changes.insert(k.clone(), v.clone()); + } + } + } + changes + } + + fn reduce_entity_relations( + &self, + mut matching_relations: Vec, + relative: &serde_json::Map, + relation_name: &str, + ) -> Result, String> { + if matching_relations.is_empty() { + return Ok(None); + } + if matching_relations.len() == 1 { + return Ok(Some(matching_relations.pop().unwrap())); + } + + let exact_match: Vec<_> = matching_relations + .iter() + .filter(|r| r.prefix.as_deref() == Some(relation_name)) + .cloned() + .collect(); + if exact_match.len() == 1 { + return Ok(Some(exact_match.into_iter().next().unwrap())); + } + + matching_relations.retain(|r| { + if let Some(prefix) = &r.prefix { + !relative.contains_key(prefix) + } else { + true + } + }); + + if matching_relations.len() == 1 { + Ok(Some(matching_relations.pop().unwrap())) + } else { + let constraints: Vec<_> = matching_relations + .iter() + .map(|r| r.constraint.clone()) + .collect(); + Err(format!( + "AMBIGUOUS_TYPE_RELATIONS: Could not reduce ambiguous type relations: {}", + constraints.join(", ") + )) + } + } + + fn get_entity_relation( + &self, + entity_type: &crate::database::r#type::Type, + relative: &serde_json::Map, + relation_name: &str, + ) -> Result, String> { + let relative_type_name = match relative.get("type").and_then(|v| v.as_str()) { + Some(t) => t, + None => return Ok(None), + }; + + let relative_type = match self.db.types.get(relative_type_name) { + Some(t) => t, + None => return Ok(None), + }; + + let mut relative_relations: Vec = Vec::new(); + + for r in self.db.relations.values() { + if r.source_type != "entity" && r.destination_type != "entity" { + let condition1 = relative_type.hierarchy.contains(&r.source_type) + && entity_type.hierarchy.contains(&r.destination_type); + let condition2 = entity_type.hierarchy.contains(&r.source_type) + && relative_type.hierarchy.contains(&r.destination_type); + + if condition1 || condition2 { + relative_relations.push(r.clone()); + } + } + } + + let mut relative_relation = + self.reduce_entity_relations(relative_relations, relative, relation_name)?; + + if relative_relation.is_none() { + let mut poly_relations: Vec = Vec::new(); + for r in self.db.relations.values() { + if r.destination_type == "entity" { + let condition1 = relative_type.hierarchy.contains(&r.source_type); + let condition2 = entity_type.hierarchy.contains(&r.source_type); + + if condition1 || condition2 { + poly_relations.push(r.clone()); + } + } + } + relative_relation = self.reduce_entity_relations(poly_relations, relative, relation_name)?; + } + + Ok(relative_relation) + } + + fn apply_entity_relation( + source_entity: &mut serde_json::Map, + source_columns: &[String], + destination_columns: &[String], + destination_entity: &serde_json::Map, + ) { + if source_columns.len() != destination_columns.len() { + return; + } + for i in 0..source_columns.len() { + if let Some(dest_val) = destination_entity.get(&destination_columns[i]) { + source_entity.insert(source_columns[i].clone(), dest_val.clone()); + } + } + } + fn quote_literal(val: &Value) -> String { match val { Value::Null => "NULL".to_string(), @@ -741,8 +849,21 @@ impl Merger { "false".to_string() } } - Value::Number(n) => n.to_string(), - Value::String(s) => format!("'{}'", s.replace('\'', "''")), + Value::Number(n) => { + if let Some(f) = n.as_f64() { + if f.fract() == 0.0 { + return f.trunc().to_string(); + } + } + n.to_string() + } + Value::String(s) => { + if s.is_empty() { + "NULL".to_string() + } else { + format!("'{}'", s.replace('\'', "''")) + } + } _ => format!( "'{}'", serde_json::to_string(val).unwrap().replace('\'', "''") diff --git a/src/tests/fixtures.rs b/src/tests/fixtures.rs index ca16641..d8cc4d3 100644 --- a/src/tests/fixtures.rs +++ b/src/tests/fixtures.rs @@ -1,1686 +1,8544 @@ #[test] -fn test_content_0() { +fn test_content_0_0() { let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_content_1() { +fn test_content_0_1() { let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_content_2() { +fn test_content_0_2() { let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_content_3() { +fn test_content_1_0() { let path = format!("{}/fixtures/content.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_unique_items_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_unique_items_1() { +fn test_unique_items_0_1() { let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_unique_items_2() { +fn test_unique_items_0_2() { let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_unique_items_3() { +fn test_unique_items_0_3() { let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_unique_items_4() { +fn test_unique_items_0_4() { let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_unique_items_5() { +fn test_unique_items_0_5() { let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_unique_items_6() { +fn test_unique_items_0_6() { let path = format!("{}/fixtures/uniqueItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 6).unwrap(); } #[test] -fn test_min_items_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_min_items_1() { +fn test_min_items_0_1() { let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_min_items_2() { +fn test_min_items_0_2() { let path = format!("{}/fixtures/minItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_additional_properties_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_additional_properties_1() { +fn test_additional_properties_0_1() { let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_additional_properties_2() { +fn test_additional_properties_0_2() { let path = format!("{}/fixtures/additionalProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_dependencies_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_dependencies_1() { +fn test_dependencies_0_1() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_dependencies_2() { +fn test_dependencies_0_2() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_dependencies_3() { +fn test_dependencies_0_3() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_dependencies_4() { +fn test_dependencies_0_4() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_dependencies_5() { +fn test_dependencies_0_5() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_dependencies_6() { +fn test_dependencies_0_6() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 6).unwrap(); } #[test] -fn test_dependencies_7() { +fn test_dependencies_1_0() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_dependencies_8() { +fn test_dependencies_1_1() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_dependencies_9() { +fn test_dependencies_1_2() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_dependencies_10() { +fn test_dependencies_2_0() { let path = format!("{}/fixtures/dependencies.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_exclusive_minimum_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_const_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_const_1() { +fn test_const_0_1() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_const_2() { +fn test_const_0_2() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_const_3() { +fn test_const_1_0() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_const_4() { +fn test_const_1_1() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_const_5() { +fn test_const_1_2() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_const_6() { +fn test_const_1_3() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 3).unwrap(); } #[test] -fn test_const_7() { +fn test_const_2_0() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_const_8() { +fn test_const_2_1() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_const_9() { +fn test_const_2_2() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 2).unwrap(); } #[test] -fn test_const_10() { +fn test_const_3_0() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_const_11() { +fn test_const_3_1() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 1).unwrap(); } #[test] -fn test_const_12() { +fn test_const_4_0() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 0).unwrap(); } #[test] -fn test_const_13() { +fn test_const_4_1() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 13).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 1).unwrap(); } #[test] -fn test_const_14() { +fn test_const_4_2() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 14).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 2).unwrap(); } #[test] -fn test_const_15() { +fn test_const_5_0() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 15).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 0).unwrap(); } #[test] -fn test_const_16() { +fn test_const_5_1() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 16).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 1).unwrap(); } #[test] -fn test_const_17() { +fn test_const_5_2() { let path = format!("{}/fixtures/const.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 17).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 2).unwrap(); } #[test] -fn test_families_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_families_1() { +fn test_families_0_1() { let path = format!("{}/fixtures/families.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_property_names_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_property_names_1() { +fn test_property_names_0_1() { let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_property_names_2() { +fn test_property_names_0_2() { let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_property_names_3() { +fn test_property_names_0_3() { let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_property_names_4() { +fn test_property_names_0_4() { let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_property_names_5() { +fn test_property_names_0_5() { let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_property_names_6() { +fn test_property_names_1_0() { let path = format!("{}/fixtures/propertyNames.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_queryer_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_queryer_1() { +fn test_queryer_0_1() { let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_not_0() { +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_1_0() { + let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); +} + +#[test] +fn test_queryer_1_1() { + let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); +} + +#[test] +fn test_queryer_1_2() { + let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); +} + +#[test] +fn test_queryer_1_3() { + let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 3).unwrap(); +} + +#[test] +fn test_queryer_1_4() { + let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 4).unwrap(); +} + +#[test] +fn test_queryer_1_5() { + let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 5).unwrap(); +} + +#[test] +fn test_not_0_0() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_not_1() { +fn test_not_0_1() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_not_2() { +fn test_not_1_0() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_not_3() { +fn test_not_1_1() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_not_4() { +fn test_not_1_2() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_not_5() { +fn test_not_2_0() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_not_6() { +fn test_not_2_1() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_not_7() { +fn test_not_2_2() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 2).unwrap(); } #[test] -fn test_not_8() { +fn test_not_3_0() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_not_9() { +fn test_not_3_1() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 1).unwrap(); } #[test] -fn test_not_10() { +fn test_not_4_0() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 0).unwrap(); } #[test] -fn test_not_11() { +fn test_not_4_1() { let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 1).unwrap(); } #[test] -fn test_items_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_items_1() { +fn test_items_0_1() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_items_2() { +fn test_items_0_2() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_items_3() { +fn test_items_0_3() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_items_4() { +fn test_items_1_0() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_items_5() { +fn test_items_1_1() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_items_6() { +fn test_items_2_0() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_items_7() { +fn test_items_2_1() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_items_8() { +fn test_items_3_0() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_items_9() { +fn test_items_3_1() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 1).unwrap(); } #[test] -fn test_items_10() { +fn test_items_3_2() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 2).unwrap(); } #[test] -fn test_items_11() { +fn test_items_3_3() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 3).unwrap(); } #[test] -fn test_items_12() { +fn test_items_3_4() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 4).unwrap(); } #[test] -fn test_items_13() { +fn test_items_3_5() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 13).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 5).unwrap(); } #[test] -fn test_items_14() { +fn test_items_4_0() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 14).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 0).unwrap(); } #[test] -fn test_items_15() { +fn test_items_4_1() { let path = format!("{}/fixtures/items.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 15).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 1).unwrap(); } #[test] -fn test_enum_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_enum_1() { +fn test_enum_0_1() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_enum_2() { +fn test_enum_1_0() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_enum_3() { +fn test_enum_1_1() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_enum_4() { +fn test_enum_1_2() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_enum_5() { +fn test_enum_1_3() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 3).unwrap(); } #[test] -fn test_enum_6() { +fn test_enum_1_4() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 4).unwrap(); } #[test] -fn test_enum_7() { +fn test_enum_2_0() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_enum_8() { +fn test_enum_2_1() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_enum_9() { +fn test_enum_2_2() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 2).unwrap(); } #[test] -fn test_enum_10() { +fn test_enum_3_0() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_enum_11() { +fn test_enum_3_1() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 1).unwrap(); } #[test] -fn test_enum_12() { +fn test_enum_3_2() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 2).unwrap(); } #[test] -fn test_enum_13() { +fn test_enum_3_3() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 13).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 3).unwrap(); } #[test] -fn test_enum_14() { +fn test_enum_3_4() { let path = format!("{}/fixtures/enum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 14).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 4).unwrap(); } #[test] -fn test_min_properties_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_min_properties_1() { +fn test_min_properties_0_1() { let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_min_properties_2() { +fn test_min_properties_0_2() { let path = format!("{}/fixtures/minProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_min_contains_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_min_contains_1() { +fn test_min_contains_0_1() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_min_contains_2() { +fn test_min_contains_1_0() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_min_contains_3() { +fn test_min_contains_1_1() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_min_contains_4() { +fn test_min_contains_1_2() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_min_contains_5() { +fn test_min_contains_1_3() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 3).unwrap(); } #[test] -fn test_min_contains_6() { +fn test_min_contains_1_4() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 4).unwrap(); } #[test] -fn test_min_contains_7() { +fn test_min_contains_2_0() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_min_contains_8() { +fn test_min_contains_2_1() { let path = format!("{}/fixtures/minContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_properties_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_properties_1() { +fn test_properties_0_1() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_properties_2() { +fn test_properties_0_2() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_properties_3() { +fn test_properties_0_3() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_properties_4() { +fn test_properties_0_4() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_properties_5() { +fn test_properties_0_5() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_properties_6() { +fn test_properties_1_0() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_properties_7() { +fn test_properties_1_1() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_properties_8() { +fn test_properties_1_2() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_properties_9() { +fn test_properties_1_3() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 3).unwrap(); } #[test] -fn test_properties_10() { +fn test_properties_2_0() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_properties_11() { +fn test_properties_2_1() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_properties_12() { +fn test_properties_3_0() { let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_max_contains_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_max_contains_1() { +fn test_max_contains_0_1() { let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_max_contains_2() { +fn test_max_contains_1_0() { let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_max_contains_3() { +fn test_max_contains_1_1() { let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_max_contains_4() { +fn test_max_contains_1_2() { let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_max_length_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_max_length_1() { +fn test_max_length_0_1() { let path = format!("{}/fixtures/maxLength.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_exclusive_maximum_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_prefix_items_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_prefix_items_1() { +fn test_prefix_items_0_1() { let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_prefix_items_2() { +fn test_prefix_items_0_2() { let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_prefix_items_3() { +fn test_prefix_items_0_3() { let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_prefix_items_4() { +fn test_prefix_items_0_4() { let path = format!("{}/fixtures/prefixItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_minimum_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_minimum_1() { +fn test_minimum_0_1() { let path = format!("{}/fixtures/minimum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_one_of_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_one_of_1() { +fn test_one_of_0_1() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_one_of_2() { +fn test_one_of_0_2() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_one_of_3() { +fn test_one_of_0_3() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_one_of_4() { +fn test_one_of_1_0() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_one_of_5() { +fn test_one_of_1_1() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_one_of_6() { +fn test_one_of_1_2() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_one_of_7() { +fn test_one_of_2_0() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_one_of_8() { +fn test_one_of_3_0() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_one_of_9() { +fn test_one_of_4_0() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 0).unwrap(); } #[test] -fn test_one_of_10() { +fn test_one_of_5_0() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 0).unwrap(); } #[test] -fn test_one_of_11() { +fn test_one_of_6_0() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 6, 0).unwrap(); } #[test] -fn test_one_of_12() { +fn test_one_of_6_1() { let path = format!("{}/fixtures/oneOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 6, 1).unwrap(); } #[test] -fn test_boolean_schema_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_boolean_schema_1() { +fn test_boolean_schema_0_1() { let path = format!("{}/fixtures/booleanSchema.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_if_then_else_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_if_then_else_1() { +fn test_if_then_else_0_1() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_if_then_else_2() { +fn test_if_then_else_1_0() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_if_then_else_3() { +fn test_if_then_else_1_1() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_if_then_else_4() { +fn test_if_then_else_2_0() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_if_then_else_5() { +fn test_if_then_else_2_1() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_if_then_else_6() { +fn test_if_then_else_3_0() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_if_then_else_7() { +fn test_if_then_else_3_1() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 1).unwrap(); } #[test] -fn test_if_then_else_8() { +fn test_if_then_else_3_2() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 2).unwrap(); } #[test] -fn test_if_then_else_9() { +fn test_if_then_else_4_0() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 0).unwrap(); } #[test] -fn test_if_then_else_10() { +fn test_if_then_else_4_1() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 1).unwrap(); } #[test] -fn test_if_then_else_11() { +fn test_if_then_else_4_2() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 2).unwrap(); } #[test] -fn test_if_then_else_12() { +fn test_if_then_else_5_0() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 0).unwrap(); } #[test] -fn test_if_then_else_13() { +fn test_if_then_else_5_1() { let path = format!("{}/fixtures/if-then-else.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 13).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 1).unwrap(); } #[test] -fn test_empty_string_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_pattern_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_pattern_1() { +fn test_pattern_0_1() { let path = format!("{}/fixtures/pattern.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_max_properties_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_max_properties_1() { +fn test_max_properties_0_1() { let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_max_properties_2() { +fn test_max_properties_0_2() { let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_max_properties_3() { +fn test_max_properties_0_3() { let path = format!("{}/fixtures/maxProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_required_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_required_1() { +fn test_required_0_1() { let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_required_2() { +fn test_required_0_2() { let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_required_3() { +fn test_required_0_3() { let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_required_4() { +fn test_required_0_4() { let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_required_5() { +fn test_required_0_5() { let path = format!("{}/fixtures/required.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_type_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_type_1() { +fn test_type_0_1() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_type_2() { +fn test_type_0_2() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_type_3() { +fn test_type_0_3() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_type_4() { +fn test_type_0_4() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_type_5() { +fn test_type_0_5() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_type_6() { +fn test_type_0_6() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 6).unwrap(); } #[test] -fn test_type_7() { +fn test_type_0_7() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 7).unwrap(); } #[test] -fn test_type_8() { +fn test_type_0_8() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 8).unwrap(); } #[test] -fn test_type_9() { +fn test_type_1_0() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_type_10() { +fn test_type_1_1() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_type_11() { +fn test_type_1_2() { let path = format!("{}/fixtures/type.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_multiple_of_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_multiple_of_1() { +fn test_multiple_of_0_1() { let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_multiple_of_2() { +fn test_multiple_of_0_2() { let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_multiple_of_3() { +fn test_multiple_of_1_0() { let path = format!("{}/fixtures/multipleOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_pattern_properties_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_pattern_properties_1() { +fn test_pattern_properties_0_1() { let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_pattern_properties_2() { +fn test_pattern_properties_0_2() { let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_pattern_properties_3() { +fn test_pattern_properties_0_3() { let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_pattern_properties_4() { +fn test_pattern_properties_0_4() { let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_pattern_properties_5() { +fn test_pattern_properties_0_5() { let path = format!("{}/fixtures/patternProperties.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_merge_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_merge_1() { +fn test_merge_0_1() { let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_merge_2() { +fn test_merge_1_0() { let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_merge_3() { +fn test_merge_1_1() { let path = format!("{}/fixtures/merge.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_all_of_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_all_of_1() { +fn test_all_of_0_1() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_all_of_2() { +fn test_all_of_0_2() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_all_of_3() { +fn test_all_of_0_3() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_all_of_4() { +fn test_all_of_1_0() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_all_of_5() { +fn test_all_of_1_1() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_all_of_6() { +fn test_all_of_1_2() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_all_of_7() { +fn test_all_of_1_3() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 3).unwrap(); } #[test] -fn test_all_of_8() { +fn test_all_of_1_4() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 4).unwrap(); } #[test] -fn test_all_of_9() { +fn test_all_of_2_0() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_all_of_10() { +fn test_all_of_2_1() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_all_of_11() { +fn test_all_of_3_0() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_all_of_12() { +fn test_all_of_4_0() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 0).unwrap(); } #[test] -fn test_all_of_13() { +fn test_all_of_5_0() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 13).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 0).unwrap(); } #[test] -fn test_all_of_14() { +fn test_all_of_6_0() { let path = format!("{}/fixtures/allOf.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 14).unwrap(); + crate::tests::runner::run_test_case(&path, 6, 0).unwrap(); } #[test] -fn test_format_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_format_1() { +fn test_format_0_1() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_format_2() { +fn test_format_0_2() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_format_3() { +fn test_format_0_3() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_format_4() { +fn test_format_0_4() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_format_5() { +fn test_format_0_5() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_format_6() { +fn test_format_0_6() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 6).unwrap(); } #[test] -fn test_format_7() { +fn test_format_0_7() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 7).unwrap(); } #[test] -fn test_format_8() { +fn test_format_0_8() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 8).unwrap(); } #[test] -fn test_format_9() { +fn test_format_0_9() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 9).unwrap(); } #[test] -fn test_format_10() { +fn test_format_0_10() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 10).unwrap(); } #[test] -fn test_format_11() { +fn test_format_0_11() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 11).unwrap(); } #[test] -fn test_format_12() { +fn test_format_0_12() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 12).unwrap(); } #[test] -fn test_format_13() { +fn test_format_0_13() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 13).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 13).unwrap(); } #[test] -fn test_format_14() { +fn test_format_0_14() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 14).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 14).unwrap(); } #[test] -fn test_format_15() { +fn test_format_0_15() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 15).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 15).unwrap(); } #[test] -fn test_format_16() { +fn test_format_0_16() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 16).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 16).unwrap(); } #[test] -fn test_format_17() { +fn test_format_0_17() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 17).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 17).unwrap(); } #[test] -fn test_format_18() { +fn test_format_0_18() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 18).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 18).unwrap(); } #[test] -fn test_format_19() { +fn test_format_0_19() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 19).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 19).unwrap(); } #[test] -fn test_format_20() { +fn test_format_0_20() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 20).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 20).unwrap(); } #[test] -fn test_format_21() { +fn test_format_0_21() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 21).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 21).unwrap(); } #[test] -fn test_format_22() { +fn test_format_0_22() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 22).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 22).unwrap(); } #[test] -fn test_format_23() { +fn test_format_0_23() { let path = format!("{}/fixtures/format.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 23).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 23).unwrap(); } #[test] -fn test_ref_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_ref_1() { +fn test_ref_0_1() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_ref_2() { +fn test_ref_1_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_ref_3() { +fn test_ref_1_1() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_ref_4() { +fn test_ref_1_2() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_ref_5() { +fn test_ref_2_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); } #[test] -fn test_ref_6() { +fn test_ref_2_1() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } #[test] -fn test_ref_7() { +fn test_ref_3_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 0).unwrap(); } #[test] -fn test_ref_8() { +fn test_ref_3_1() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 3, 1).unwrap(); } #[test] -fn test_ref_9() { +fn test_ref_4_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 9).unwrap(); + crate::tests::runner::run_test_case(&path, 4, 0).unwrap(); } #[test] -fn test_ref_10() { +fn test_ref_5_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 10).unwrap(); + crate::tests::runner::run_test_case(&path, 5, 0).unwrap(); } #[test] -fn test_ref_11() { +fn test_ref_6_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 11).unwrap(); + crate::tests::runner::run_test_case(&path, 6, 0).unwrap(); } #[test] -fn test_ref_12() { +fn test_ref_6_1() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 12).unwrap(); + crate::tests::runner::run_test_case(&path, 6, 1).unwrap(); } #[test] -fn test_ref_13() { +fn test_ref_7_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 13).unwrap(); + crate::tests::runner::run_test_case(&path, 7, 0).unwrap(); } #[test] -fn test_ref_14() { +fn test_ref_8_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 14).unwrap(); + crate::tests::runner::run_test_case(&path, 8, 0).unwrap(); } #[test] -fn test_ref_15() { +fn test_ref_9_0() { let path = format!("{}/fixtures/ref.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 15).unwrap(); + crate::tests::runner::run_test_case(&path, 9, 0).unwrap(); } #[test] -fn test_maximum_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_maximum_1() { +fn test_maximum_0_1() { let path = format!("{}/fixtures/maximum.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_min_length_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_min_length_1() { +fn test_min_length_0_1() { let path = format!("{}/fixtures/minLength.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_max_items_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_max_items_1() { +fn test_max_items_0_1() { let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_max_items_2() { +fn test_max_items_0_2() { let path = format!("{}/fixtures/maxItems.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_contains_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); } #[test] -fn test_contains_1() { +fn test_contains_0_1() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 1).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 1).unwrap(); } #[test] -fn test_contains_2() { +fn test_contains_0_2() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 2).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 2).unwrap(); } #[test] -fn test_contains_3() { +fn test_contains_0_3() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 3).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 3).unwrap(); } #[test] -fn test_contains_4() { +fn test_contains_0_4() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 4).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 4).unwrap(); } #[test] -fn test_contains_5() { +fn test_contains_0_5() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 5).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 5).unwrap(); } #[test] -fn test_contains_6() { +fn test_contains_1_0() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 6).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); } #[test] -fn test_contains_7() { +fn test_contains_1_1() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 7).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); } #[test] -fn test_contains_8() { +fn test_contains_1_2() { let path = format!("{}/fixtures/contains.json", env!("CARGO_MANIFEST_DIR")); - crate::tests::runner::run_test_file_at_index(&path, 8).unwrap(); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); } #[test] -fn test_merger_0() { +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_file_at_index(&path, 0).unwrap(); + crate::tests::runner::run_test_case(&path, 0, 0).unwrap(); +} + +#[test] +fn test_merger_1_0() { + let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 0).unwrap(); +} + +#[test] +fn test_merger_1_1() { + let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 1).unwrap(); +} + +#[test] +fn test_merger_1_2() { + let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 1, 2).unwrap(); +} + +#[test] +fn test_merger_2_0() { + let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 2, 0).unwrap(); +} + +#[test] +fn test_merger_2_1() { + let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR")); + crate::tests::runner::run_test_case(&path, 2, 1).unwrap(); } diff --git a/src/tests/runner.rs b/src/tests/runner.rs index 4460308..4379141 100644 --- a/src/tests/runner.rs +++ b/src/tests/runner.rs @@ -1,17 +1,17 @@ use serde::Deserialize; +use std::collections::HashMap; use std::fs; +use std::sync::{Arc, OnceLock, RwLock}; #[derive(Debug, Deserialize)] -struct TestSuite { +pub struct TestSuite { #[allow(dead_code)] - description: String, - database: serde_json::Value, - tests: Vec, + pub description: String, + pub database: serde_json::Value, + pub tests: Vec, } -use crate::tests::types::{ExpectBlock, TestCase}; - -use crate::validator::Validator; +use crate::tests::types::TestCase; use serde_json::Value; pub fn deserialize_some<'de, D>(deserializer: D) -> Result, D::Error> @@ -22,87 +22,128 @@ where Ok(Some(v)) } -pub fn run_test_file_at_index(path: &str, index: usize) -> Result<(), String> { - let content = - fs::read_to_string(path).unwrap_or_else(|_| panic!("Failed to read file: {}", path)); - let suite: Vec = serde_json::from_str(&content) - .unwrap_or_else(|e| panic!("Failed to parse JSON in {}: {}", path, e)); +// Type alias for easier reading +type CompiledSuite = Arc)>>; - if index >= suite.len() { - panic!("Index {} out of bounds for file {}", index, path); +// Global cache mapping filename -> Vector of (Parsed JSON suite, Compiled Database) +static CACHE: OnceLock>> = OnceLock::new(); + +fn get_cached_file(path: &str) -> CompiledSuite { + let cache_lock = CACHE.get_or_init(|| RwLock::new(HashMap::new())); + + let file_data = { + let read_guard = cache_lock.read().unwrap(); + read_guard.get(path).cloned() + }; + + match file_data { + Some(data) => data, + None => { + let mut write_guard = cache_lock.write().unwrap(); + // double check in case another thread compiled while we waited for lock + if let Some(data) = write_guard.get(path) { + data.clone() + } else { + let content = + fs::read_to_string(path).unwrap_or_else(|_| panic!("Failed to read file: {}", path)); + let suites: Vec = serde_json::from_str(&content) + .unwrap_or_else(|e| panic!("Failed to parse JSON in {}: {}", path, e)); + + let mut compiled_suites = Vec::new(); + for suite in suites { + let db_result = crate::database::Database::new(&suite.database); + if let Err(drop) = db_result { + let error_messages: Vec = drop + .errors + .into_iter() + .map(|e| format!("Error {} at path {}: {}", e.code, e.details.path, e.message)) + .collect(); + panic!( + "System Setup Compilation failed for {}:\n{}", + path, + error_messages.join("\n") + ); + } + compiled_suites.push((suite, Arc::new(db_result.unwrap()))); + } + + let new_data = Arc::new(compiled_suites); + write_guard.insert(path.to_string(), new_data.clone()); + new_data + } + } + } +} + +pub fn run_test_case(path: &str, suite_idx: usize, case_idx: usize) -> Result<(), String> { + let file_data = get_cached_file(path); + + if suite_idx >= file_data.len() { + panic!("Suite Index {} out of bounds for file {}", suite_idx, path); } - let group = &suite[index]; + let (group, db) = &file_data[suite_idx]; + + if case_idx >= group.tests.len() { + panic!( + "Case Index {} out of bounds for suite {} in file {}", + case_idx, suite_idx, path + ); + } + + let test = &group.tests[case_idx]; let mut failures = Vec::::new(); - let db_json = group.database.clone(); - let db_result = crate::database::Database::new(&db_json); - if let Err(drop) = db_result { - let error_messages: Vec = drop - .errors - .into_iter() - .map(|e| format!("Error {} at path {}: {}", e.code, e.details.path, e.message)) - .collect(); - return Err(format!( - "System Setup Compilation failed:\n{}", - error_messages.join("\n") - )); - } - let db = db_result.unwrap(); - let validator = Validator::new(std::sync::Arc::new(db)); - // 4. Run Tests - for test in group.tests.iter() { - // Provide fallback for legacy expectations if `expect` block was missing despite migration script - let expected_success = test - .expect - .as_ref() - .map(|e| e.success) - .unwrap_or(test.valid.unwrap_or(false)); - let _expected_errors = test - .expect - .as_ref() - .and_then(|e| e.errors.clone()) - .unwrap_or(test.expect_errors.clone().unwrap_or(vec![])); + // Provide fallback for legacy expectations if `expect` block was missing despite migration script + let _expected_success = test + .expect + .as_ref() + .map(|e| e.success) + .unwrap_or(test.valid.unwrap_or(false)); + let _expected_errors = test + .expect + .as_ref() + .and_then(|e| e.errors.clone()) + .unwrap_or(test.expect_errors.clone().unwrap_or(vec![])); - match test.action.as_str() { - "validate" => { - let result = test.run_validate(validator.db.clone()); - if let Err(e) = result { - println!("TEST VALIDATE ERROR FOR '{}': {}", test.description, e); - failures.push(format!( - "[{}] Validate Test '{}' failed. Error: {}", - group.description, test.description, e - )); - } - } - "merge" => { - let result = test.run_merge(validator.db.clone()); - if let Err(e) = result { - println!("TEST MERGE ERROR FOR '{}': {}", test.description, e); - failures.push(format!( - "[{}] Merge Test '{}' failed. Error: {}", - group.description, test.description, e - )); - } - } - "query" => { - let result = test.run_query(validator.db.clone()); - if let Err(e) = result { - println!("TEST QUERY ERROR FOR '{}': {}", test.description, e); - failures.push(format!( - "[{}] Query Test '{}' failed. Error: {}", - group.description, test.description, e - )); - } - } - _ => { + match test.action.as_str() { + "validate" => { + let result = test.run_validate(db.clone()); + if let Err(e) = result { + println!("TEST VALIDATE ERROR FOR '{}': {}", test.description, e); failures.push(format!( - "[{}] Unknown action '{}' for test '{}'", - group.description, test.action, test.description + "[{}] Validate Test '{}' failed. Error: {}", + group.description, test.description, e )); } } + "merge" => { + let result = test.run_merge(db.clone()); + if let Err(e) = result { + println!("TEST MERGE ERROR FOR '{}': {}", test.description, e); + failures.push(format!( + "[{}] Merge Test '{}' failed. Error: {}", + group.description, test.description, e + )); + } + } + "query" => { + let result = test.run_query(db.clone()); + if let Err(e) = result { + println!("TEST QUERY ERROR FOR '{}': {}", test.description, e); + failures.push(format!( + "[{}] Query Test '{}' failed. Error: {}", + group.description, test.description, e + )); + } + } + _ => { + failures.push(format!( + "[{}] Unknown action '{}' for test '{}'", + group.description, test.action, test.description + )); + } } if !failures.is_empty() {