class CommandLineTaskParserSpec extends Specification {
    def selector = Stub(BuildTaskSelector)
    def defaultBuild = Stub(BuildState)
    def taskConfigurer = Mock(CommandLineTaskConfigurer)
    def task = Mock(Task)
    def task2 = Mock(Task)
    def task3 = Mock(Task)
    def parser = new CommandLineTaskParser(taskConfigurer, selector, defaultBuild)

    def setup() {

    def "artifact key must be provided"() {
        when:
        index.store(null, Stub(File), TestHashCodes.hashCodeFrom(0))

        then:
        def e = thrown(IllegalArgumentException)
        e.message == "key cannot be null"
    }

    def "stored artifact is put into persistentIndexedCache"() {
        given:
        1 * cacheAccessCoordinator.createCache(persistentCacheFile, _, _) >> persistentIndexedCache

            task showArtifacts {
                def filesA = configurations.a
                def idsA = configurations.a.incoming.artifacts.resolvedArtifacts.map { it.id }
                def filesB = configurations.b
                def idsB = configurations.b.incoming.artifacts.resolvedArtifacts.map { it.id }
                def filesC = configurations.c

    def userHomeDir = temporaryFolder.createDir("user-home")
    def usedGradleVersions = Mock(UsedGradleVersions) {
        getUsedGradleVersions() >> ([] as SortedSet)
    }
    def progressMonitor = Mock(CleanupProgressMonitor)

    @Subject def cleanupAction = new WrapperDistributionCleanupAction(userHomeDir, usedGradleVersions)

    def "deletes distributions for unused versions"() {

        given:
        def message1 = unicast()
        def message2 = broadcast()
        def message3 = unicast()
        def endpoint1 = queue.newEndpoint()
        def endpoint2 = queue.newEndpoint()

        and:
        queue.dispatch(message1)
        queue.dispatch(message2)
        queue.dispatch(message3)

        when:
        queue.empty(endpoint1)

    def "closes services for home dir when another home dir is in use"() {
        def dir1 = new File("home-dir-1")
        def dir2 = new File("home-dir-2")

        given:
        def servicesHomeDir1 = homeDirServices.getServicesFor(dir1)
        def homeDir1Service = servicesHomeDir1.get(SomeHomeDirService)

        when:
        def services1 = homeDirServices.getServicesFor(dir2)

    }

    def "collects all failures from actions when running sequentially"() {
        given:
        def action1 = Mock(Supplier)
        def action2 = Mock(Supplier)
        def action3 = Mock(Supplier)
        def failure1 = new RuntimeException()
        def failure2 = new RuntimeException()

        when:
        runner.run([action1, action2, action3])

        then:

        0 * listener.onDiscovered(_)
    }

    def "notifies listener of node with matching ancestor"() {
        def a = node("a")
        def b = node("a.b")
        def c = node("a.b.c")
        def d = node("a.b.d")
        def e = node("a.b.c.e")
        def f = node("d")

        given:
        def listener = Mock(ModelListener) {
            matches(_) >> true

    }

    def 'getType yields the listener class'() {
        expect:
        broadcast.type == TestListener
    }

    def 'source object does nothing when no listeners are added'() {
        expect:
        broadcast.source.event1("param")
    }

    def 'visit listeners does nothing when no listeners are added'() {
        def visitor = Mock(Action)

        when:

    }

    def "replaces original class with transformed in JAR without manifest"() {
        given:
        def original = jar(testDir.file("original.jar")) {
            manifest {}

            entry("Foo.class", ORIGINAL_CLASS)
        }

        def transformed = jar(testDir.file("transformed.jar")) {
            withoutManifest()

            entry("Foo.class", INSTRUMENTED_CLASS)