* a report for multiple projects, by setting the value of the
 * <code>projects</code> property. Here's how to generate an HTML
 * dependency report for all the projects of a multi-project build, for example:
 * <pre>
 * htmlDependencyReport {
 *     projects = project.allprojects
 * }
 * </pre>
 * <p>

    fun registerProject(projectPath: Path, dir: File, buildDir: File)

    fun getProject(path: String): ProjectInternal

    // Creates all registered projects for this build
    fun createProjects()

    fun addIncludedBuild(buildDefinition: BuildDefinition, settingsFile: File?, buildPath: Path): ConfigurationCacheBuild

        because("ProjectBuilder tests load services from a Gradle distribution.")
    }
    integTestDistributionRuntimeOnly(project(":distributions-full"))  {
        because("There are integration tests that assert that all the tasks of a full distribution are reported (these should probably move to ':integTests').")
    }
}

packageCycles {
    excludePatterns.add("org/gradle/api/reporting/model/internal/*")

            [(color): Iterables.getOnlyElement(nodeIds)]
        }
    }

    private Map<String, List<Map<String, ?>>> getTransformStepIdentities() {
        def ops = buildOperations.all(CalculateTaskGraphBuildOperationType)
        def identities = ops.collect { op ->
            def plannedNodes = op.result.executionPlan as List<Map<String, ?>>

        try {
            return ClassLoader.getSystemClassLoader().loadClass(agentClassName);
        } catch (ClassNotFoundException e) {
            // This typically means that the agent is not loaded at all.
            // For now, this happens when running in a no-daemon mode, or when the Gradle distribution is not available.
            LoggerFactory.getLogger(AgentControl.class).debug("Agent {} is not loaded", agentClassName);

// This test doesn't live in :instrumentation-agent to avoid the latter being implicitly added to
// the test runtime classpath as part of the main source set's output.
// It is important to have the agent appended to the classpath of all integration tests.
class AgentApplicationTest extends AbstractIntegrationSpec {
    def "agent is enabled by default"() {
        given:
        withDumpAgentStatusTask()

        when:
        succeeds()

        then:
        fixture.assertNoConfigurationCache()

        originalUpdatedModel.children.path == [":a", ":b"]
        originalUpdatedModel.children.all[0].tasks.name.contains("something")


        when:
        executer.withArguments(ENABLE_CLI)
        def updatedModel = fetchModel(GradleProject)

        then:
        fixture.assertStateUpdated {

    @Test
    fun `defers evaluation of Callable objects`() {
        assertDeferredEvaluationOf(callable()) {
            call()
        }
    }

    @Test
    fun `defers evaluation of dynamic Callable fields`() {
        assertDeferredEvaluationOf(BeanOf(callable())) {
            value.call()
        }
    }

    @Test
    fun `defers evaluation of static Callable fields`() {

        then:
        hasSystemProperty('mySystemProperty', 'defined in the client JVM')
    }

    def "Passing an empty map to withSystemProperties() hides all client system properties"() {
        setup:
        toolingApi.requireDaemons() // no separate daemon JVM -> all client JVM system properties are expected to be visible

        when:
        runTask { withSystemProperties([:]) }

        then:

                override fun apply(project: Project) {
                    var value = ${read.kotlinExpression}
                    println("apply = " + value)

                    // Call from a function body
                    val f = { p: String ->
                        println("\$p FUNCTION = " + System.getProperty("FUNCTION"))
                    }
                    f("apply")