then:
        visited == 2
        deps as List == [dependency]
    }

    def "collection dependencies are live"() {
        def task = Stub(Task)
        def dependency1 = Stub(Task)
        def dependency2 = Stub(Task)
        def dependencySource = Mock(TaskDependencyContainer)

        def collection = new TestCollection() {
            @Override

    }

    def "ignores external module jar from runtime ClassLoader"() {
        def classesDir = tmpDir.createDir("some-module/build/classes/java/main")
        def staticResourcesDir = tmpDir.createDir("some-module/src/main/resources")
        def cl = classLoaderFor([externalDependency, classesDir, resourcesDir, staticResourcesDir, externalRuntimeDep])
        def registry = new DefaultModuleRegistry(cl, ClassPath.EMPTY, null)

        expect:

        then:
        def ex = thrown(RuntimeException)
        ex.is(failure1)
    }

    def stopOfFixedSizedScheduledExecutorRethrowsFirstExecutionException() {
        given:
        def failure1 = new RuntimeException()
        def action1 = {
            throw failure1
        }

        def failure2 = new RuntimeException()
        def action2 = {
            instant.broken2

    def 'wraps original exception when it is not a contextual exception'() {
        given:
        def failure = new RuntimeException()
        def analyser = analyser()
        def result = []

        when:
        analyser.collectFailures(failure, result)

        then:
        result.size() == 1
        def transformedFailure = result[0]

        def location = new ExternalResourceName("thing")
        def fileStore = Mock(CacheAwareExternalResourceAccessor.ResourceFileStore)
        def localCandidates = Mock(LocallyAvailableResourceCandidates)
        def remoteResource = Mock(ExternalResource)
        def metaData = Mock(ExternalResourceMetaData)
        def localResource = new DefaultLocallyAvailableResource(cachedFile, TestUtil.checksumService)

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 "visits the correct snapshots"() {
        def parent = tmpDir.createDir()
        def dir1 = parent.createDir("dir1")
        def dir1dir2 = dir1.createDir("dir2")
        def dir1dir2dir3 = dir1dir2.createDir("dir3")
        def dir1dir2dir4 = dir1dir2.createDir("dir4")
        def dir1dir5 = dir1.createDir("dir5/and/more")
        def dir6 = parent.createDir("dir6")

        expect:

    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

    static def generator = new ManagedProxyClassGenerator()
    static Map<List<?>, Class<?>> generated = [:]
    def typeConverter = new DefaultTypeConverter(Stub(FileResolver))

    def "generates a node backed view class for an interface"() {
        expect:
        def impl = newNodeBackedInstance(SomeType)
        impl instanceof SomeType
    }

    def "generates a view class for an interface"() {