${customGroovyComponentWithName("TestComponent")}
            ${customGroovyComponentWithName("CustomComponent")}

            components {
                registerBinding(SoftwareComponent, DefaultTestComponent)
                registerBinding(CustomComponent, DefaultCustomComponent)
                first {
                    value = 1
                }
                second(SoftwareComponent) {

    def container = new DefaultAuthenticationContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)

    def setup() {
        container.registerBinding(TestAuthentication, DefaultTestAuthentication)
        container.registerBinding(CustomTestAuthentication, DefaultCustomTestAuthentication)
    }

    def "can add multiple authentication schemes with common supertype"() {
        when:

            components {
                registerBinding(JvmSoftwareComponentInternal, DefaultJvmSoftwareComponent)
            }
        """
    }

    private static final String factoryRegistrationKotlin() {
        """
            ${importStatements()}

            components {
                registerBinding(JvmSoftwareComponentInternal::class.java, DefaultJvmSoftwareComponent::class.java)

            interface ThingB extends BaseThing { }

            def container = project.objects.polymorphicDomainObjectContainer(BaseThing)
            container.registerBinding(ThingA, ThingA)
            container.registerBinding(ThingB, ThingB)
            container.register("a", ThingA) {
                value = 0
            }
            container.register("b", ThingB) {
                value = 1

     *
     * @param type a public domain object type
     * @param implementationType the corresponding implementation type
     * @param <U> a public domain object type
     */
    <U extends T> void registerBinding(Class<U> type, final Class<? extends U> implementationType);

        testAggregation.setVisible(false);

        ReportingExtension reporting = project.getExtensions().getByType(ReportingExtension.class);
        reporting.getReports().registerBinding(AggregateTestReport.class, DefaultAggregateTestReport.class);

        ObjectFactory objects = project.getObjects();

            @Override
            public U create(String name) {
                return factory.call(name);
            }
        });
    }

    @Override
    public <U extends T> void registerBinding(Class<U> type, final Class<? extends U> implementationType) {
        registerFactory(type, new NamedDomainObjectFactory<U>() {
            boolean named = Named.class.isAssignableFrom(implementationType);

        for (Map.Entry<Class<Authentication>, Class<? extends Authentication>> e : authenticationSchemeRegistry.getRegisteredSchemes().entrySet()) {
            authenticationContainer.registerBinding(e.getKey(), e.getValue());
        }
        AuthenticationSupporter authenticationSupporter = new AuthenticationSupporter(instantiator, objectFactory, authenticationContainer, providerFactory);

            { it instanceof Named ? it.name : "unknown" } as Named.Namer, CollectionCallbackActionDecorator.NOOP)

        container.registerBinding(UnnamedPerson, DefaultUnnamedPerson)
        container.registerBinding(CtorNamedPerson, DefaultCtorNamedPerson)

        when:
        container.create("fred", UnnamedPerson)
        container.create("barney", CtorNamedPerson)

        then:

            });
        });

        ReportingExtension reporting = project.getExtensions().getByType(ReportingExtension.class);
        reporting.getReports().registerBinding(JacocoCoverageReport.class, DefaultJacocoCoverageReport.class);

        // Iterate and configure each user-specified report.
        reporting.getReports().withType(JacocoCoverageReport.class).all(report -> {