}
        '''.stripIndent()
        file('src/test/java/org/gradle/factory/TestNGFactory.java') << '''
            package org.gradle.factory;
            import org.testng.annotations.Factory;

            public class TestNGFactory {
                @Factory
                public Object[] factory() {
                    return new Object[]{ new FactoryTest("First"), new FactoryTest("Second") };

    }

    public static DocumentBuilderFactory newInstance(final boolean external) {
        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        if (!external) {
            try {
                factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
                factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
            } catch (final Exception e) {

    level = DeprecationLevel.HIDDEN,
  )
  @JvmStatic
  fun createFactory(client: OkHttpClient) = createFactory(client as Call.Factory)

  @JvmStatic
  fun createFactory(callFactory: Call.Factory): EventSource.Factory {
    return EventSource.Factory { request, listener ->
      val actualRequest =
        if (request.header("Accept") == null) {

        def result = selector.select(variantSetOf(variants), requestedAttributes, false, factory)

        then:
        result == transformed

        1 * attributeMatcher.matches(_, _, _) >> Collections.emptyList()
        1 * consumerProvidedVariantFinder.findTransformedVariants(variants, requestedAttributes) >> transformedVariants

    private final TransformStepNodeFactory transformStepNodeFactory;
    private final ConcurrentMap<VariantKey, ResolvedArtifactSet> variants = new ConcurrentHashMap<>();
    private final Factory externalFactory = this::doCreateExternal;
    private final Factory projectFactory = this::doCreateProject;

/**
 * Synchronizes access to some resource, by making sure that 2 threads do not try to produce it at the same time.
 * The resource to be accessed is represented by a key, and the factory is whatever needs to be done to produce it.
 * This is <b>not</b> a cache. The factory should take care of caching wherever it makes sense.
 *
 * <p>

}

repositories {
    mavenCentral()
}

// tag::object-factory[]
tasks.register("myObjectFactoryTask") {
    doLast {
        def objectFactory = project.objects
        def myProperty = objectFactory.property(String)
        myProperty.set("Hello, Gradle!")
        println myProperty.get()
    }
}
// end::object-factory[]

// tag::object-factory-inject[]
abstract class MyObjectFactoryTask extends DefaultTask {

    private final FileAccess fileAccess;
    private final Supplier<BTreePersistentIndexedCache<K, V>> factory;
    private BTreePersistentIndexedCache<K, V> cache;

    public DefaultMultiProcessSafeIndexedCache(Supplier<BTreePersistentIndexedCache<K, V>> factory, FileAccess fileAccess) {
        this.factory = factory;
        this.fileAccess = fileAccess;
    }

    @Override
    public String toString() {

        this.deprecatedForConsumption = deprecatedForConsumption;
        this.canBeResolved = canBeResolved;
        this.dependencies = dependencies;
        this.variants = variants;
        this.factory = factory;
        this.artifacts = artifacts;
    }

    @Override

    ServiceRegistry loggingServices = new DefaultServiceRegistry()
    boolean useCurrentProcess
    BuildActionsFactory factory

    def setup() {
        def factoryLoggingManager = Mock(Factory) { _ * create() >> Mock(LoggingManagerInternal) }
        loggingServices.add(OutputEventListener, Mock(OutputEventListener))