*
     * @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.
     */

    def "creating ids after loading is not allowed"() {
        def factory = new ConfigurationCacheableIdFactory()

        when:
        factory.idRecreated()
        factory.idRecreated()
        then:
        noExceptionThrown()

        when:
        factory.createId()
        then:
        def e = thrown(IllegalStateException)

        given:
        OptionValueNotationParserFactory factory = new OptionValueNotationParserFactory()
        when:
        def parser = factory.toComposite(String.class);
        then:
        parser.parseNotation("somestring") == "somestring"
    }

    def "creates notationparser for handling handles enums"(){
        given:
        OptionValueNotationParserFactory factory = new OptionValueNotationParserFactory()
        when:

            }

            class NestedExtension {
                ObjectFactory factory

                @javax.inject.Inject
                NestedExtension(ObjectFactory of) {
                    factory = of
                }

                String name

                Person getRiker() {
                   factory.newInstance(Person, 'Riker')
                }

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

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

        expect:

    private final Factory<DependencyResolutionServices> factory;
    private DependencyResolutionServices dependencyResolutionServices;

    public PluginDependencyResolutionServices(Factory<DependencyResolutionServices> factory) {
        this.factory = factory;
    }

    private DependencyResolutionServices getDependencyResolutionServices() {

        when:
        compare(null, factory)

        then:
        !unchanged
        0 * factory.create()
    }

    def "always unchanged with incomplete local metadata"() {
        given:
        configureMetadata(local, etag, lastModified, contentLength)

        when:
        compare(local, factory)

        then:
        !unchanged
        0 * factory.create()

        where: