given:
        buildFile << """
            task graph {
                def root = configurations.compile.incoming.resolutionResult.rootComponent
                doLast {
                    root.get()
                }
            }
"""

        when:
        module.pom.expectGet()
        module2.pom.expectGet()

        then:
        succeeds("graph")
    }

}
task a {
    def files = configurations.a
    doLast {
        files.files
    }
}
task b {
    def files = configurations.b
    doLast {
        files.files
    }
}
task block1 {
    doLast {
        ${blockingServer.callFromBuild("block1")}
    }
}
block1.mustRunAfter a
b.mustRunAfter block1

task block2 {
    doLast {
        ${blockingServer.callFromBuild("block2")}
    }
}

    def "logs info message for exact match"() {
        setup:
        buildFile << """
            tasks.register("sanityCheck") {
                doLast { }
            }
            tasks.register("safetyCheck") {
                doLast { }
            }
        """

        when:
        run("sanityCheck", "--info")

        then:
        outputContains("Task name matched 'sanityCheck'")

}

// tag::scope[]
tasks {
    test {
        testLogging.showStackTraces = true
    }
    val myCheck by registering {
        doLast { /* assert on something meaningful */ }
    }
    check {
        dependsOn(myCheck)
    }
    register("myHelp") {
        doLast { /* do something helpful */ }
    }
}

            file("build/libs1/test-1.3.jar.txt").readLines() == ["1", "2", "3", "4", "5"]
            file("build/libs1/test2-2.3.jar.txt").readLines() == ["1", "2", "3", "4", "5"]
        } else {
            // Counter is isolated at execution time, so transforms will see the increment in each tasks' doLast { }

    }
    doLast {
        println("NAMED TASK1 - doLast: This is executed during the execution phase")
    }
}

tasks.named("task2"){
    println("NAMED TASK2: This is executed during the configuration phase")
    doFirst {
        println("NAMED TASK2 - doFirst: This is executed during the execution phase")
    }
    doLast {

val compile by tasks.registering {
    doLast {
        println("We are doing the compile.")
    }
}

compile {
    doFirst {
        // Here you would put arbitrary conditions in real life.
        if (true) {
            throw StopExecutionException()
        }
    }
}
tasks.register("myTask") {
    dependsOn(compile)
    doLast {
        println("I am not affected")
    }

            include('sub')
        """
        buildFile << """
            def test = tasks.register('test') {
                doLast {
                     println 'test executed'
                }
            }

            tasks.register('build') {
                doLast {
                     println 'build executed'
                }
                dependsOn test

                }
            }
        }
        task mutateBeforeResolve {
            doLast {
                def classes = configurations.compile.outgoing.variants['classes']
                classes.attributes.attribute(format, 'classes2')
            }
        }
        task mutateAfterResolve {
            doLast {
                configurations.compile.resolve()

        given:
        tmpDir.newFile("src/samples/build.gradle") << """
task compile {
    doLast {
        println "compiling source"
    }
}
task testCompile(dependsOn: compile) {
    doLast {
        println "compiling test source"
    }
}
task test(dependsOn: [compile, testCompile]) {
    doLast {
        println "running unit tests"
    }
}
task build(dependsOn: [test])
"""