TestClassProcessor processor;
        if (processors.size() < maxProcessors) {
            processor = factory.create();
            rawProcessors.add(processor);
            Actor actor = actorFactory.createActor(processor);
            processor = actor.getProxy(TestClassProcessor.class);
            actors.add(actor);
            processors.add(processor);
            processor.startProcessing(resultProcessor);
        } else {

    }
  }

  public void testDaemon_false() {
    ThreadFactory factory = builder.setDaemon(false).build();
    Thread thread = factory.newThread(monitoredRunnable);
    assertFalse(thread.isDaemon());
  }

  public void testDaemon_true() {
    ThreadFactory factory = builder.setDaemon(true).build();
    Thread thread = factory.newThread(monitoredRunnable);

class FactoriesTest extends Specification {
    def "factory runs given runnable and returns null"() {
        Runnable r = Mock()
        Factory<String> factory = Factories.toFactory(r)

        when:
        def result = factory.create()

        then:
        result == null

        and:
        1 * r.run()
        0 * r._
    }

    def "factory gets cached"() {
        given:

        factory.path(subDir) == factory.path("file://${relpath(childFile)}/../..")
        factory.path("file://${relpath(subDir)}") != factory.path("file://${relpath(childFile)}")

        // Using absolute paths
        factory.path(subDir) == factory.path("file://${subDir.absolutePath}")

        // Using replacement variables

    def "returns a factory for a given type"() {
        def fooFactory = factory(Foo)
        def buzzFactory = factory(Buzz)
        registry.withFactories(buzzFactory, fooFactory)

        expect:
        registry.lookup(fooFactory.id) == fooFactory
    }

    def "returns null for unknown type"() {
        def fooFactory = factory(Foo)
        def barFactory = factory(Bar)
        def buzzFactory = factory(Buzz)

        n2.toString() == "b"

        n1.is(factory.named(CustomNamed, "a"))
        n2.is(factory.named(CustomNamed, "b"))

        !n1.is(factory.named(Named, "a"))
        !n2.is(factory.named(Named, "b"))

        n1 instanceof Managed
    }

    def "can unpack and recreate instance of subtype of Named"() {
        expect:
        def n1 = factory.named(CustomNamed, "a")
        n1 instanceof Managed

        cleanup:
        factory.close()
    }

    void "can visit all caches created by factory"() {
        def visited = [] as Set

        when:
        factory.open(tmpDir.testDirectory.file('foo'), "foo", [prop: 'value'], mode(Shared), null, null)
        factory.open(tmpDir.testDirectory.file('bar'), "bar", [prop: 'value'], mode(Shared), null, null)

        expect:
        factory.windows == factory.windows
        factory.linux == factory.linux
        factory.macOS == factory.macOS
        factory.windows.x86 == factory.windows.x86
        factory.linux.x86_64 == factory.linux.x86_64
        factory.windows.architecture("arm") == factory.windows.architecture("arm")
        factory.os("fushia").architecture("arm") == factory.os("fushia").architecture("arm")
    }

        expect:
        def attributes = factory.of(FOO, "foo")
        factory.of(FOO, "foo").is(attributes)
        factory.of(FOO, "other") != attributes
        factory.of(BAR, "foo") != attributes
    }

    def "can concatenate immutable attributes sets"() {
        when:
        def set1 = factory.of(FOO, "foo")
        def set2 = factory.of(BAR, "bar")
        def union = factory.concat(set1, set2)

        then:

     * @param type the type of objects created by the factory
     * @param factory the factory to register
     * @param <U> the type of objects created by the factory
     *
     * @throws IllegalArgumentException if the specified type is not a subtype of the container element type
     */
    @Override
    <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory);

    /**