@ClassRule
    @Shared
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def factory = new DefaultFileCollectionFactory(TestFiles.pathToFileResolver(tmpDir.testDirectory), TestFiles.taskDependencyFactory(), TestFiles.directoryFileTreeFactory(), Stub(Factory), Stub(PropertyHost), TestFiles.fileSystem())

    def "lazily queries contents of collection created from MinimalFileSet"() {

                if (!anyOrganisation && !anyModule) {
                    return factory.moduleId(moduleId);
                } else if (!anyModule) {
                    return factory.module(moduleId.getName());
                } else if (!anyOrganisation) {
                    return factory.group(moduleId.getGroup());
                } else {
                    return factory.everything();
                }
            } else {

        _ * textOutputFactory.create(_, _) >> textOutput
    }

    def "delegates to each action factory to configure the command-line parser and create the action"() {
        def rawAction = Mock(Action<? super ExecutionListener>)

        when:
        def commandLineExecution = factory.convert(["--some-option"])
        commandLineExecution.execute(executionListener)

        then:

    final DefaultUrlArtifactRepository.Factory urlArtifactRepositoryFactory = new DefaultUrlArtifactRepository.Factory(fileResolver);
    final ProviderFactory providerFactory = Mock()

    final DefaultBaseRepositoryFactory factory = new DefaultBaseRepositoryFactory(

        TasksFactory factory = new TasksFactory(false)

        when:
        factory.allTasks = [:]
        factory.allTasks.put(project, [task] as Set)
        def tasks = factory.getTasks(project)

        then:
        tasks.empty
    }

    def "returns tasks"() {
        TasksFactory factory = new TasksFactory(true)

        when:
        factory.allTasks = [:]

  private val routePlanner = FakeRoutePlanner()
  private val factory = routePlanner.factory
  private val taskFaker = routePlanner.taskFaker
  private val peer = MockHttp2Peer()

  /** The fake task runner prevents the cleanup runnable from being started.  */
  private val addressA = factory.newAddress("a")
  private val routeA1 = factory.newRoute(addressA)
  private val addressB = factory.newAddress("b")

    private final ChainingHttpHandler.HandlerFactory<TrackingHttpHandler> factory;

    public DefaultExpectedRequests(ChainingHttpHandler.HandlerFactory<TrackingHttpHandler> factory) {
        this.factory = factory;
    }

    public TrackingHttpHandler create(WaitPrecondition previous) {
        return factory.create(previous);
    }

        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);
    }