when:
        def node = factory.getOrCreateNode(a)

        then:
        factory.getOrCreateNode(a).is(node)
    }

    void 'can add multiple nodes'() {
        when:
        factory.getOrCreateNode(a)
        factory.getOrCreateNode(b)

        then:
        factory.tasks == [a, b] as Set
    }

    void 'reset state'() {
        when:
        factory.getOrCreateNode(a)

        for (ManagedFactory factory : factories) {
            register(factory);
        }
        return this;
    }

    @Override
    @Nullable
    public ManagedFactory lookup(int id) {
        ManagedFactory factory = managedFactoryCache.getIfPresent(id);
        if (factory == null && parent != null) {
            factory = parent.lookup(id);
        }
        return factory;
    }

      throws InvocationTargetException, IllegalAccessException {
    T returnValue = factory.invoke(null, args.toArray());
    if (returnValue == null) {
      Assert.assertTrue(
          factory + " returns null but it's not annotated with @Nullable", isNullable(factory));
    }
    return returnValue;
  }

  /**

    <T> T withLocks(Collection<? extends ResourceLock> locks, Factory<T> factory) {
        return factory.create()
    }

    @Override
    void withLocks(Collection<? extends ResourceLock> locks, Runnable action) {
        action.run()
    }

    @Override
    <T> T withoutLocks(Collection<? extends ResourceLock> locks, Factory<T> factory) {
        return factory.create()
    }

    @Override

        def actor2 = factory.createActor(target)

        then:
        actor2.is(actor1)
    }

    def returnsTargetObjectIfTargetObjectIsAnActor() {
        when:
        def actor1 = factory.createActor(target)
        def actor2 = factory.createActor(actor1)

        then:
        actor2.is(actor1)
    }

    def nonBlockingActorAndProxyAreBothMarkedAsThreadSafe() {

     *
     * @param factory
     *            {@link SchemaFactory}。{@literal null}であってはいけません
     * @param schema
     *            スキーマファイル。{@literal null}であってはいけません
     * @return {@link Schema}
     */
    public static Schema newSchema(final SchemaFactory factory, final File schema) {
        assertArgumentNotNull("factory", factory);
        assertArgumentNotNull("schema", schema);

    def factory = new DefaultImmutableModuleIdentifierFactory()

    def "creates module"() {
        when:
        def m = factory.module('foo', 'bar')

        then:
        m.group == 'foo'
        m.name == 'bar'
    }

    def "caches module ids"() {
        when:
        def m1 = factory.module('foo', 'bar')
        def m2 = factory.module('foo', 'bar')

        then:

        }
        def action2 = {
            thread.block()
            instant.completed2
        }

        when:
        async {
            factory.create("1").execute(action1)
            factory.create("2").execute(action2)
            factory.stop()
            instant.stopped
        }

        then:
        instant.stopped > instant.completed1
        instant.stopped > instant.completed2
    }

import java.util.Set;
import java.util.stream.Collectors;

class Unions {
    private final ExcludeFactory factory;

    public Unions(ExcludeFactory factory) {
        this.factory = factory;
    }

    /**
     * Tries to compute an union of 2 specs.
     * The result MUST be a simplification, otherwise this method returns null.
     */

        expect:
        factory.getDefaultDistribution(tmpDir.testDirectory.createDir("child"), true).displayName == "Gradle distribution '$zipFileUri'"
    }

    def usesTheCurrentVersionAsTheDefaultDistributionWhenNoWrapperPropertiesFilePresent() {
        def uri = new DistributionLocator().getDistributionFor(GradleVersion.current()).toASCIIString()

        expect: