'''

        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:

            import ${DefaultTask.name};
            import ${TaskAction.name};
            import ${Nested.name};
            import ${Files.name};
            import ${IOException.name};

            public abstract class ProducerTask extends DefaultTask {
                @Nested
                public abstract Params getParams();

                @TaskAction

        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:

    void finalizeIncludedBuilds();

    /**
     * Creates an included build. An included build is-a nested build whose projects and outputs are treated as part of the composite build.
     */
    IncludedBuildState addIncludedBuild(BuildDefinition buildDefinition);

    /**
     * Creates an included build. An included build is-a nested build whose projects and outputs are treated as part of the composite build.
     *

    }

    def 'can use nested class as test pattern'() {
        given:
        file('src/test/java/EnclosingClass.java') << '''
            import org.junit.jupiter.api.Test;
            import org.junit.jupiter.api.Nested;
            import static org.junit.jupiter.api.Assertions.assertEquals;

            class EnclosingClass {
                @Nested
                class NestedClass {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.platform;

import org.gradle.api.Describable;
import org.gradle.api.tasks.Nested;
import org.gradle.internal.HasInternalProtocol;
import org.gradle.platform.base.Platform;

/**
 * A target platform for building native binaries. Each target platform is given a name, and may optionally be given

                import org.gradle.api.DefaultTask
                import org.gradle.api.tasks.Nested
                import org.gradle.api.tasks.OutputFile
                import org.gradle.api.tasks.TaskAction
                import java.io.File

                open class TaskWithNestedAction : DefaultTask() {
                    @get: Nested
                    lateinit var action: ${actionType}

                    @get: OutputFile

			Current:  `{"thing":null}`,
			Modified: `{"nested":{"value":5},"thing":null}`,

			ExpectedTwoWay:         `{"nested":{"value":5}}`,
			ExpectedTwoWayResult:   `{"nested":{"value":5},"thing":null}`,
			ExpectedThreeWay:       `{"nested":{"value":5}}`,
			ExpectedThreeWayResult: `{"nested":{"value":5},"thing":null}`,
		},
		"nested null values in original are preserved": {

        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'"