'''

        expect:
        succeeds 'assertActionExecutionOrder'
    }

    def "can execute #description during task creation action execution"() {
        createDirs("nested")
        settingsFile << "include 'nested'"
        buildFile << """
            tasks.create("foo") {
                ${code}
            }
        """

        expect:
        succeeds "foo"

        where:

        expect:
        rootsOf(from([
            "/tulry/nested-cli/nested-cli-nested/buildSrc",
            "/tulry/nested-cli/buildSrc/buildSrc",
            "/tulry/nested/buildSrc"
        ].collect({ new File(it) }))) == [
            "/tulry/nested-cli/nested-cli-nested/buildSrc",
            "/tulry/nested-cli/buildSrc/buildSrc",
            "/tulry/nested/buildSrc"
        ]
    }

                            valueMatchers:
                            - stringMatch:
                                exact: nested
                            - stringMatch:
                                prefix: nested-prefix-
                            - stringMatch:
                                suffix: -suffix-nested
                            - stringMatch:
                                safeRegex:

        child2.identityPath == Path.path(":child1:child2")

        nestedRootProject.toString() == "project ':nested'"
        nestedRootProject.displayName == "project ':nested'"
        nestedRootProject.path == ":"
        nestedRootProject.buildTreePath == ":nested"
        nestedRootProject.identityPath == Path.path(":nested")

        nestedChild1.toString() == "project ':nested:child1'"

    def setup() {
        expectReindentedValidationMessage()
    }

    def "implementation of nested property in Groovy build script is tracked"() {
        setupTaskClassWithActionProperty()
        buildFile << """
            task myTask(type: TaskWithActionProperty) {
                action = ${originalImplementation}

        def suite = new DefaultTestSuiteDescriptor("suiteId", "FastTests");
        def test = new DefaultTestDescriptor("testId", "DogTest", "shouldBarkAtStrangers");

        when:
        adapter.started(suite, new TestStartEvent(100L))
        adapter.started(test, new TestStartEvent(100L, 'suiteId'))
        adapter.completed('testId', new TestCompleteEvent(200L, ResultType.SKIPPED))
        adapter.completed('suiteId', new TestCompleteEvent(200L))

    }

    CrossVersionPerformanceResults run() {
        assumeShouldRun()

        def results = new CrossVersionPerformanceResults(
            testClass: testClassName,
            testId: testId,
            previousTestIds: previousTestIds.collect { it.toString() }, // Convert GString instances
            testProject: testProject,
            tasks: tasksToRun.collect { it.toString() },

        macros << macro("TEST", '"test1.h"')
        macros << macro("IGNORE", '"broken"')
        macros << macro("NESTED", '"test2.h"')
        macros << macro("NESTED", '"test3.h"')
        macros << macro("TEST", "NESTED")

        expect:
        def result = resolve(include('TEST'))
        result.complete

    }

    def "finalized file collection ignores later changes to nested file collections"() {
        buildFile """
            def nested = objects.fileCollection()
            def name = 'a'
            nested.from { name }

            def names = ['b', 'c']
            nested.from(names)

            def files = objects.fileCollection()
            files.from(nested)
            files.finalizeValue()
            name = 'ignore-me'

            }
        }
    }

    @TargetGradleVersion(">=8.8")
    def "reports display names of nested test classes"() {
        file("src/test/java/org/example/TestingAStackDemo.java") << """package org.example;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

import java.util.EmptyStackException;
import java.util.Stack;