required("embedded", "apiVersion"),
			required("embedded", "kind"),
		}},
		{name: "nested", object: `
{
  "nested": {
    "embedded": {}
  }
}`, errors: []validationMatch{
			required("nested", "apiVersion"),
			required("nested", "kind"),
			required("nested", "embedded", "apiVersion"),
			required("nested", "embedded", "kind"),
		}},
		{name: "items", object: `
{
  "items": [{}]

        output.writeString(value);
    }

    @Override
    public void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception {
        if (nested == null) {
            nested = new KryoBackedEncoder(new OutputStream() {
                @Override
                public void write(byte[] buffer, int offset, int length) {
                    if (length == 0) {

        pluginDir.file("src/main/groovy/ProducerTask.groovy") << """
            import ${DefaultTask.name}
            import ${TaskAction.name}
            import ${Nested.name}

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

                @TaskAction
                def run() {
                    params.outFile.get().asFile.text = "content"

        String simpleResultMethod() { "simpleResultValue" }
    }

    static trait NestedResult {
        Nested getNested() { new Object().withTraits(Nested) }
    }

    static trait Nested {
        String getNestedValue() { "nestedValue" }

        String toString() { "Nested" }
    }

 */

package org.gradle.nativeplatform;

import org.gradle.api.tasks.Nested;

/**
 * Represents a combination of operating system and cpu architecture that a variant might be built for.
 *
 * @since 5.1
 */
public interface TargetMachine {
    /**
     * Returns the target operating system
     */
    @Nested
    OperatingSystemFamily getOperatingSystemFamily();

    /**

        2        | "tasks.register('myTask', CustomTask, 'abc', null)"
    }

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

        expect:
        fails "foo"

        run(":buildSrc:jar")
        // Task will not run when configuration cache is enabled
    }

    def "can execute a task from nested buildSrc from the command line"() {
        createDirs("nested")
        file("settings.gradle") << """
            includeBuild("nested")
        """
        file("nested/buildSrc/build.gradle") << """
            task something {
                doLast { }
            }
        """

import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.expressionTypeProvider.AbstractHLExpressionTypeTest;
import org.jetbrains.kotlin.test.TestMetadata;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

import java.io.File;
import java.util.regex.Pattern;

import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.expressionTypeProvider.AbstractHLExpressionTypeTest;
import org.jetbrains.kotlin.test.TestMetadata;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

import java.io.File;
import java.util.regex.Pattern;

		`"k8s.io/kubernetes/cmd/import-boss/testdata/nested-fwd/aaa" -> "k8s.io/kubernetes/cmd/import-boss/testdata/nested-fwd/forbidden-by-both" is forbidden`,
		`"k8s.io/kubernetes/cmd/import-boss/testdata/nested-fwd/aaa" -> "k8s.io/kubernetes/cmd/import-boss/testdata/nested-fwd/forbidden-by-root" is forbidden`,
		`"k8s.io/kubernetes/cmd/import-boss/testdata/nested-fwd/aaa" -> "k8s.io/kubernetes/cmd/import-boss/testdata/nested-fwd/forbidden-by-sub" is forbidden`,