}

    def "visits all resolution failures"() {
        given:
        def throwable = Mock(Throwable)
        def resolveEx = Mock(ResolveException)

        def unresolved = Mock(UnresolvedDependency) {
            getProblem() >> throwable
        }

        def results1 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), null)

    }

    def "returns this when same target requested"() {
        def selector = Stub(ProjectComponentSelector)
        def dep = new LocalComponentDependencyMetadata(selector, "to", [] as List, [], false, false, true, false, false, null)

        expect:
        dep.withTarget(selector).is(dep)
    }

    def "selects the target configuration from target component"() {

    }

    def "generated wrapper does not change unnecessarily"() {
        def wrapperJar = file("gradle/wrapper/gradle-wrapper.jar")
        def wrapperProperties = file("gradle/wrapper/gradle-wrapper.properties")
        run "wrapper", "--gradle-version", "2.2.1", "--no-validate-url"
        def testFile = file("modtime").touch()
        def originalTime = testFile.lastModified()
        when:

    def factory = Mock(PayloadClassLoaderFactory)
    def classpathTransformer = Mock(CachedClasspathTransformer)

    def registry = new DaemonSidePayloadClassLoaderFactory(factory, classpathTransformer)

    def "creates ClassLoader for classpath"() {
        def url1 = new URL("http://localhost/file1.jar")
        def url2 = new URL("http://localhost/file2.jar")

        given:

    }

    def "the lock holder starts the release request only once and discards additional requests in the meantime"() {
        given:
        def requestReceived = false
        def terminate = false
        setupLockOwner {
            requestReceived = true
            while(!terminate) { Thread.sleep(100) } //block the release action thread
        }

        when:

    }

    def "ignores missing dependency if there is an #relation relation in the other direction"() {
        def sourceDir = "src"
        file(sourceDir).createDir()
        def outputDir = "build/output"

        buildFile """
            task firstTask {
                inputs.dir("${sourceDir}")
                def outputDir = file("${outputDir}")
                outputs.dir(outputDir)

                }
            }
        """
    }

    def <T> T fetchModel(Class<T> type = SomeToolingModel.class, String... tasks = null) {
        def model = null
        result = toolingApiExecutor.runBuildWithToolingConnection { connection ->
            def output = new ByteArrayOutputStream()
            def error = new ByteArrayOutputStream()
            def args = executer.allArgs
            args.remove("--no-daemon")

    private identifier = new OperationIdentifier(2)

    def setup() {
        def diagnosticsFactory = new NoOpProblemDiagnosticsFactory()

        problemEmitter = Mock(ProblemEmitter)
        def currentBuildRef = Mock(CurrentBuildOperationRef)

        currentBuildRef.getId() >> identifier

        def buildOperationProgressEventEmitter = Mock(BuildOperationProgressEventEmitter)

    def "does not report work item progress events when WORK_ITEM operations are not requested"() {
        when:
        def events = runBuild("runInWorker", EnumSet.complementOf(EnumSet.of(OperationType.WORK_ITEM)))

        then:
        def taskOperation = events.operation("Task :runInWorker")
        taskOperation.assertIsTask()
        taskOperation.descendants { it.descriptor.displayName == "TestWork" }.empty
    }

        buildFinishedHandler.getResult() == "build"
    }

    def "failures from action are received and future actions not run"() {
        def projectsLoadedHandler = new IntermediateResultHandlerCollector()
        def buildFinishedHandler = new IntermediateResultHandlerCollector()

        when:
        withConnection { connection ->
            def action = connection.action()