@Test
    @DisplayName("Should parse schema with complex nested types")
    void shouldParseSchemaWithNestedTypes() throws Exception {
        // Given
        Path protoPath = Paths.get(TEST_RESOURCES_DIR, "with_nested_types.proto");
        String protoContent = Files.readString(protoPath);
        
        // When
        ProtobufSchema schema = ProtobufSchemaParser.parseSchema(protoContent, Collections.emptyMap());
        
        // Then
        Descriptors.FileDescriptor fileDescriptor = schema.getFileDescriptor();
        
        // Verify the main message type
        Descriptors.Descriptor mainMessageDescriptor = fileDescriptor.findMessageTypeByName("ComplexNestedMessage");
        assertNotNull(mainMessageDescriptor);
        
        // Verify nested enum
        Descriptors.EnumDescriptor statusEnum = mainMessageDescriptor.findEnumTypeByName("Status");
        assertNotNull(statusEnum);
        assertEquals(4, statusEnum.getValues().size());
        assertEquals("UNKNOWN", statusEnum.getValues().get(0).getName());
        assertEquals("ACTIVE", statusEnum.getValues().get(1).getName());
        
        // Verify nested Address message
        Descriptors.Descriptor addressDescriptor = mainMessageDescriptor.findNestedTypeByName("Address");
        assertNotNull(addressDescriptor);
        assertEquals(4, addressDescriptor.getFields().size());
        
        // Verify deeply nested GeoLocation message
        Descriptors.Descriptor geoLocationDescriptor = addressDescriptor.findNestedTypeByName("GeoLocation");
        assertNotNull(geoLocationDescriptor);
        assertEquals(3, geoLocationDescriptor.getFields().size());
        
        // Verify deepest nested Accuracy message
        Descriptors.Descriptor accuracyDescriptor = geoLocationDescriptor.findNestedTypeByName("Accuracy");
        assertNotNull(accuracyDescriptor);
        assertEquals(2, accuracyDescriptor.getFields().size());
        
        // Verify recursive TreeNode message
        Descriptors.Descriptor treeNodeDescriptor = mainMessageDescriptor.findNestedTypeByName("TreeNode");
        assertNotNull(treeNodeDescriptor);
        
        // Verify recursive field in TreeNode
        Descriptors.FieldDescriptor childrenField = treeNodeDescriptor.findFieldByName("children");
        assertNotNull(childrenField);
        assertTrue(childrenField.isRepeated());
        assertEquals(Descriptors.FieldDescriptor.Type.MESSAGE, childrenField.getType());
        assertEquals(treeNodeDescriptor, childrenField.getMessageType());
        
        // Verify ContactInfo with oneof
        Descriptors.Descriptor contactInfoDescriptor = mainMessageDescriptor.findNestedTypeByName("ContactInfo");
        assertNotNull(contactInfoDescriptor);
        
        // Verify oneof fields
        Descriptors.OneofDescriptor oneofDescriptor = contactInfoDescriptor.getOneofs().get(0);
        assertEquals("contact", oneofDescriptor.getName());
        assertEquals(3, oneofDescriptor.getFields().size());
        assertTrue(oneofDescriptor.getFields().stream()
                .anyMatch(field -> field.getName().equals("email")));
        assertTrue(oneofDescriptor.getFields().stream()
                .anyMatch(field -> field.getName().equals("phone")));
        assertTrue(oneofDescriptor.getFields().stream()
                .anyMatch(field -> field.getName().equals("physical_address")));
        
        // Verify map fields
        Descriptors.FieldDescriptor labeledAddressesField = mainMessageDescriptor.findFieldByName("labeled_addresses");
        assertNotNull(labeledAddressesField);
        assertTrue(labeledAddressesField.isMapField());
        assertEquals(Descriptors.FieldDescriptor.Type.STRING, labeledAddressesField.getMessageType().findFieldByName("key").getType());
        assertEquals(addressDescriptor, labeledAddressesField.getMessageType().findFieldByName("value").getMessageType());
        
        // Verify repeated fields
        Descriptors.FieldDescriptor secondaryAddressesField = mainMessageDescriptor.findFieldByName("secondary_addresses");
        assertNotNull(secondaryAddressesField);
        assertTrue(secondaryAddressesField.isRepeated());
        assertEquals(addressDescriptor, secondaryAddressesField.getMessageType());
    }
Tests that verify parsing schema files with Google Well-Known Types and other complex protobuf features.

Note: These tests are currently disabled because they require access to the Well-Known Type definition files
which are not bundled with the test resources. In a real environment, these would be available
through the protobuf library. To make these tests pass, you would need to:  
1. Include the well-known type .proto files in your test resources
2. Make them available to the ProtobufSchemaParser when parsing

Note: The current implementation does not support the `extend` feature.
core/src/test/java/kafka/automq/table/deserializer/proto/parse/ProtobufSchemaWellKnownTypesTest.java