start {
            loader.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken)
        }
        async {
            thread.blockUntil.busy
            loader.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken)
        }

        then:
        instant.idle < instant.created

class JansiLibraryFactoryTest extends Specification {

    def factory = new JansiLibraryFactory()
    def resolver = Mock(JansiRuntimeResolver)

    def setup() {
        factory.jansiRuntimeResolver = resolver
    }

    def "jansi library can be created for MacOSX"() {
        when:
        JansiLibrary jansiLibrary = factory.create()

        then:

        registerFactory(type, factory, null);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor) {
        checkCanRegister(type, descriptor);
        delegate.registerFactory(type, factory);
    }

    private volatile TestClassProcessor processor;

    public RestartEveryNTestClassProcessor(Factory<TestClassProcessor> factory, long restartEvery) {
        this.factory = factory;
        this.restartEvery = restartEvery;
    }

    @Override
    public void startProcessing(TestResultProcessor resultProcessor) {
        this.resultProcessor = resultProcessor;
    }

    @Override

        expect:
        factory.sourceDirectorySet("name", "display") != null
    }

    def "list property has empty list as value"() {
        expect:
        def property = factory.listProperty(String)
        property.present
        property.get().empty
    }

    def "can create list property with primitive type"() {
        given:
        def property = factory.listProperty(type)

        expect:

public class DefaultUnscopedCacheBuilderFactory implements UnscopedCacheBuilderFactory {
    private final CacheFactory factory;

    public DefaultUnscopedCacheBuilderFactory(CacheFactory factory) {
        this.factory = factory;
    }

    @Override
    public CacheBuilder cache(File baseDir) {
        return new DefaultCacheBuilder(factory, baseDir);
    }

import org.gradle.internal.Factories;
import org.gradle.internal.Factory;

import java.io.IOException;

@ThreadSafe
public class SimpleModelRuleDescriptor extends AbstractModelRuleDescriptor {

    private final Factory<String> factory;

    public SimpleModelRuleDescriptor(final Factory<String> descriptor) {
        this.factory = new Factory<String>() {
            String cachedValue;
            @Override

        return track(new Factory<Iterable<? extends Completion>>() {
            @Override
            public Iterable<? extends Completion> create() {
                return TimeTrackingProcessor.super.getCompletions(element, annotation, member, userText);
            }
        });
    }

    private <T> T track(Factory<T> factory) {
        stopwatch.start();
        try {

        when:
        async {
            threadCount.times { i ->
                def nextValue = i.toString()
                start {
                    Factory<String> factory = new Factory<String>() {
                        @Override
                        String create() {
                            assert System.getProperty(presetPropertyName) == nextValue

    private static final BaseEncoding ENCODING = BaseEncoding.base32().lowerCase().omitPadding();
    private static final Pattern PATTERN = Pattern.compile("[a-z2-7]{26}");

    private static final Factory<UniqueId> FACTORY = new Factory<UniqueId>() {
        @Override
        public UniqueId create() {
            return generate();
        }
    };

    private final String value;

    public static UniqueId from(UUID uuid) {