Add context inside of tests

build.rs

@@ -80,7 +80,7 @@ fn avro_{name}() {{
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }}
 "##,
             name = case.name,
@@ -105,7 +105,7 @@ fn bigquery_{name}() {{
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }}
 "##,
             name = case.name,

src/bigquery.rs

@@ -398,7 +398,7 @@ mod tests {
             "type": "null"
         });
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
             "type": "STRING",
             "mode": "NULLABLE",
@@ -412,7 +412,7 @@ mod tests {
             "type": {"atom": "integer"}
         });
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
             "type": "INT64",
             "mode": "REQUIRED",
@@ -427,7 +427,7 @@ mod tests {
             "nullable": true,
         });
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
             "type": "INT64",
             "mode": "NULLABLE",
@@ -445,7 +445,7 @@ mod tests {
                     {"type": {"atom": "integer"}},
         ]}}});
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
             "type": "INT64",
             "mode": "NULLABLE",
@@ -468,7 +468,7 @@ mod tests {
                                 "test-nested-atom": {"type": {"atom": "number"}}
                             }}}}}}}});
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
             "type": "RECORD",
             "mode": "REQUIRED",
@@ -492,7 +492,7 @@ mod tests {
                     "type": {"atom": "integer"}},
         }}});
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
             "type": "INT64",
             "mode": "REPEATED",
@@ -513,7 +513,7 @@ mod tests {
             }
         });
         let tag: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = tag.translate_into().unwrap();;
+        let bq: Tag = tag.translate_into(None).unwrap();;
         let expect = json!({
             "type": "STRING",
             "mode": "REQUIRED",
@@ -530,7 +530,7 @@ mod tests {
                 "value": {"type": {"atom": "integer"}}
         }}});
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
         "type": "RECORD",
         "mode": "REPEATED",
@@ -548,7 +548,7 @@ mod tests {
             "nullable": true
         });
         let jschema: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Tag = jschema.translate_into().unwrap();
+        let bq: Tag = jschema.translate_into(None).unwrap();
         let expect = json!({
            "type": "TIMESTAMP",
            "mode": "NULLABLE",
@@ -561,7 +561,7 @@ mod tests {
         // Nameless tags are top-level fields that should be rooted by default
         let data = json!({"type": {"atom": "integer"}});
         let ast: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Schema = ast.translate_into().unwrap();
+        let bq: Schema = ast.translate_into(None).unwrap();
         let expect = json!([{
             "name": DEFAULT_COLUMN,
             "mode": "REQUIRED",
@@ -585,7 +585,7 @@ mod tests {
                                 "test-nested-atom": {"type": {"atom": "boolean"}}
                             }}}}}}}});
         let ast: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Schema = ast.translate_into().unwrap();;
+        let bq: Schema = ast.translate_into(None).unwrap();;
         let expect = json!([{
             "name": "test_object",
             "mode": "REQUIRED",
@@ -610,7 +610,7 @@ mod tests {
                 "value": {"type": {"atom": "integer"}}
         }}});
         let ast: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq: Schema = ast.translate_into().unwrap();;
+        let bq: Schema = ast.translate_into(None).unwrap();;
         let expect = json!([{
             "name": "root",
             "type": "RECORD",

src/jsonschema.rs

@@ -448,7 +448,7 @@ mod tests {
             "type": "null"
         });
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
             "type": "null",
             "nullable": true,
@@ -462,7 +462,7 @@ mod tests {
             "type": "integer"
         });
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
             "type": {"atom": "integer"},
             "nullable": false,
@@ -476,7 +476,7 @@ mod tests {
             "type": ["null", "integer"]
         });
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
             "type": {
                 "union": {
@@ -511,7 +511,7 @@ mod tests {
                     "test-null": {"type": "null"}
                 }}}});
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
         "nullable": false,
         "type": {
@@ -549,7 +549,7 @@ mod tests {
             }
         });
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
         "nullable": false,
         "type": {
@@ -583,7 +583,7 @@ mod tests {
             }
         });
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
         "nullable": false,
         "type": {
@@ -605,7 +605,7 @@ mod tests {
             ],
         });
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
         "nullable": true,
         "type": {
@@ -652,7 +652,7 @@ mod tests {
             "format": "date-time"
         });
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into().unwrap();
+        let ast: ast::Tag = schema.translate_into(None).unwrap();
         let expect = json!({
             "type": {"atom": "datetime"},
             "nullable": false,

tests/transpile_avro.rs

@@ -22,7 +22,7 @@ fn avro_test_array_with_atomics() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -81,7 +81,7 @@ fn avro_test_array_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -98,7 +98,7 @@ fn avro_test_atomic() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -123,7 +123,7 @@ fn avro_test_atomic_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -143,7 +143,7 @@ fn avro_test_incompatible_atomic_multitype() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -169,7 +169,7 @@ fn avro_test_incompatible_atomic_multitype_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -187,7 +187,7 @@ fn avro_test_datetime() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -210,7 +210,7 @@ fn avro_test_map_with_atomics() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -269,7 +269,7 @@ fn avro_test_map_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -295,7 +295,7 @@ fn avro_test_map_with_pattern_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -323,7 +323,7 @@ fn avro_test_map_with_pattern_and_additional_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -352,7 +352,7 @@ fn avro_test_incompatible_map_with_pattern_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -380,7 +380,7 @@ fn avro_test_incompatible_map_with_pattern_and_additional_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -462,7 +462,7 @@ fn avro_test_object_with_atomics_is_sorted() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -521,7 +521,7 @@ fn avro_test_object_with_atomics_required() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -589,7 +589,7 @@ fn avro_test_object_with_atomics_required_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -662,7 +662,7 @@ fn avro_test_object_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -680,7 +680,7 @@ fn avro_test_object_empty_record() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -704,7 +704,7 @@ fn avro_test_oneof_atomic() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -733,7 +733,7 @@ fn avro_test_oneof_atomic_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -757,7 +757,7 @@ fn avro_test_incompatible_oneof_atomic() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -789,7 +789,7 @@ fn avro_test_incompatible_oneof_atomic_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -856,7 +856,7 @@ fn avro_test_oneof_object_with_atomics() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -935,7 +935,7 @@ fn avro_test_oneof_object_merge() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -1075,7 +1075,7 @@ fn avro_test_oneof_object_merge_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -1104,7 +1104,7 @@ fn avro_test_incompatible_oneof_atomic_and_object() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -1138,7 +1138,7 @@ fn avro_test_incompatible_oneof_object() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -1188,7 +1188,7 @@ fn avro_test_incompatible_oneof_object_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }
 
 #[test]
@@ -1267,5 +1267,5 @@ fn avro_test_oneof_object_merge_nullability() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input));
+    assert_eq!(expected, convert_avro(&input, None));
 }

tests/transpile_bigquery.rs

@@ -23,7 +23,7 @@ fn bigquery_test_array_with_atomics() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -67,7 +67,7 @@ fn bigquery_test_array_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -88,7 +88,7 @@ fn bigquery_test_atomic() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -112,7 +112,7 @@ fn bigquery_test_atomic_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -136,7 +136,7 @@ fn bigquery_test_incompatible_atomic_multitype() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -161,7 +161,7 @@ fn bigquery_test_incompatible_atomic_multitype_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -183,7 +183,7 @@ fn bigquery_test_datetime() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -219,7 +219,7 @@ fn bigquery_test_map_with_atomics() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -275,7 +275,7 @@ fn bigquery_test_map_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -314,7 +314,7 @@ fn bigquery_test_map_with_pattern_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -355,7 +355,7 @@ fn bigquery_test_map_with_pattern_and_additional_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -397,7 +397,7 @@ fn bigquery_test_incompatible_map_with_pattern_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -438,7 +438,7 @@ fn bigquery_test_incompatible_map_with_pattern_and_additional_properties() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -488,7 +488,7 @@ fn bigquery_test_object_with_atomics_is_sorted() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -534,7 +534,7 @@ fn bigquery_test_object_with_atomics_required() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -583,7 +583,7 @@ fn bigquery_test_object_with_atomics_required_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -629,7 +629,7 @@ fn bigquery_test_object_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -651,7 +651,7 @@ fn bigquery_test_object_empty_record() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -679,7 +679,7 @@ fn bigquery_test_oneof_atomic() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -707,7 +707,7 @@ fn bigquery_test_oneof_atomic_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -735,7 +735,7 @@ fn bigquery_test_incompatible_oneof_atomic() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -766,7 +766,7 @@ fn bigquery_test_incompatible_oneof_atomic_with_null() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -815,7 +815,7 @@ fn bigquery_test_oneof_object_with_atomics() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -869,7 +869,7 @@ fn bigquery_test_oneof_object_merge() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -961,7 +961,7 @@ fn bigquery_test_oneof_object_merge_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -994,7 +994,7 @@ fn bigquery_test_incompatible_oneof_atomic_and_object() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -1032,7 +1032,7 @@ fn bigquery_test_incompatible_oneof_object() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -1086,7 +1086,7 @@ fn bigquery_test_incompatible_oneof_object_with_complex() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }
 
 #[test]
@@ -1146,5 +1146,5 @@ fn bigquery_test_oneof_object_merge_nullability() {
     "#;
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input));
+    assert_eq!(expected, convert_bigquery(&input, None));
 }