#[test]
    fn test_nested_record_resolution() {
        let schema_str = r#"
        {
          "type": "record",
          "name": "Sample",
          "namespace": "test",
          "fields": [
            { "name": "key", "type": "string" },
            {
              "name": "nested",
              "type": {
                "type": "record",
                "name": "Nested",
                "fields": [
                  { "name": "nested_int", "type": "int" }
                ]
              }
            },
            { "name": "nestedAgain", "type": "Nested" },
            { "name": "nestedArray", "type": { "type": "array", "items": "Nested" } },
            { "name": "nestedMap", "type": { "type": "map", "values": "Nested" } }
          ]
        }
        "#;

        let schema: Schema = serde_json::from_str(schema_str).unwrap();

        let mut resolver = Resolver::default();
        let avro_data_type = make_data_type(&schema, None, &mut resolver, false, false).unwrap();

        if let Codec::Struct(fields) = avro_data_type.codec() {
            assert_eq!(fields.len(), 5);

            // key
            assert_eq!(fields[0].name(), "key");
            assert!(matches!(fields[0].data_type().codec(), Codec::Utf8));

            // nested
            assert_eq!(fields[1].name(), "nested");
            let nested_data_type = fields[1].data_type();
            if let Codec::Struct(nested_fields) = nested_data_type.codec() {
                assert_eq!(nested_fields.len(), 1);
                assert_eq!(nested_fields[0].name(), "nested_int");
                assert!(matches!(nested_fields[0].data_type().codec(), Codec::Int32));
            } else {
                panic!(
                    "'nested' field is not a struct but {:?}",
                    nested_data_type.codec()
                );
            }

            // nestedAgain
            assert_eq!(fields[2].name(), "nestedAgain");
            let nested_again_data_type = fields[2].data_type();
            assert_eq!(
                nested_again_data_type.codec().data_type(),
                nested_data_type.codec().data_type()
            );

            // nestedArray
            assert_eq!(fields[3].name(), "nestedArray");
            if let Codec::List(item_type) = fields[3].data_type().codec() {
                assert_eq!(
                    item_type.codec().data_type(),
                    nested_data_type.codec().data_type()
                );
            } else {
                panic!("'nestedArray' field is not a list");
            }

            // nestedMap
            assert_eq!(fields[4].name(), "nestedMap");
            if let Codec::Map(value_type) = fields[4].data_type().codec() {
                assert_eq!(
                    value_type.codec().data_type(),
                    nested_data_type.codec().data_type()
                );
            } else {
                panic!("'nestedMap' field is not a map");
            }
        } else {
            panic!("Top-level schema is not a struct");
        }
    }