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:

        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:

        TestClassProcessor asyncProcessor2 = Mock()
        Actor actor1 = Mock()
        Actor actor2 = Mock()

        startProcessor()

        when:
        processor.processTestClass(test)

        then:
        1 * factory.create() >> processor1
        1 * actorFactory.createActor(processor1) >> actor1
        1 * actor1.getProxy(TestClassProcessor) >> asyncProcessor1

        metadata.getExtraAttributes() >> ImmutableMap.copyOf([(key): "bar"])
        metadata.getStatus() >> "status"
        metadata.getBranch() >> "branch"
        def factory = new MetadataDescriptorFactory(metadata)

        when:
        def descriptor = factory.createDescriptor(IvyModuleDescriptor)

        then:
        descriptor.branch == "branch"
        descriptor.ivyStatus == "status"