},
                    new SisuDiBridgeModule(false));
        }

        @Test
        void testPlexus() throws Exception {
            List<ModelParser> parsers = container.lookupList(ModelParser.class);
            assertNotNull(parsers);
            assertEquals(1, parsers.size());
            Map<String, ModelParser> parsersMap = container.lookupMap(ModelParser.class);

    }

    @Override
    @Nonnull
    public Type require(String id) {
        requireNonNull(id, "id cannot be null");
        return usedTypes.computeIfAbsent(id, i -> {
            Type type = lookup.lookupList(TypeProvider.class).stream()
                    .flatMap(p -> p.provides().stream())
                    .filter(t -> Objects.equals(id, t.id()))
                    .findFirst()
                    .orElse(null);

        return container.lookup(role, roleHint);
    }

    @Deprecated
    public List<Object> lookupList(String role) throws ComponentLookupException {
        return container.lookupList(role);
    }

    @Deprecated
    public Map<String, Object> lookupMap(String role) throws ComponentLookupException {
        return container.lookupMap(role);
    }

    }

    @Test
    void testMetadataGeneratorFactory() throws ComponentLookupException {
        List<MetadataGeneratorFactory> factories = plexusContainer.lookupList(MetadataGeneratorFactory.class);
        assertNotNull(factories);
        factories.forEach(f -> System.out.println(f.getClass().getName()));
        assertEquals(3, factories.size());
    }

    @Test

    }

    private <T> Collection<T> getExtensionComponents(Collection<MavenProject> projects, Class<T> role) {
        Collection<T> foundComponents = new LinkedHashSet<>();
        foundComponents.addAll(lookup.lookupList(role));
        foundComponents.addAll(getProjectScopedExtensionComponents(projects, role));
        return foundComponents;
    }

            @Override
            public <T> Optional<T> lookupOptional(Class<T> type, String name) {
                return Optional.empty();
            }

            @Override
            public <T> List<T> lookupList(Class<T> type) {
                return List.of();
            }

            @Override
            public <T> Map<String, T> lookupMap(Class<T> type) {
                return Map.of();
            }