import ${DefaultTask.name}
            import ${RegularFileProperty.name}
            import ${TaskAction.name}
            import ${Nested.name}

            open class ProducerTask: DefaultTask() {
                @Nested
                val params: Params = project.objects.newInstance(Params::class.java)

                @TaskAction
                fun run() {

                }
        """
        file("included/settings.gradle") << """
            rootProject.name = 'included'
            includeBuild '../nested'
        """

        file("nested/build.gradle") << """
            group = 'com.acme'
            version = '0.x'

            configurations {
                    create 'default'
                }

  }

  public void testSetFuture() throws Exception {
    SettableFuture<String> future = SettableFuture.create();
    SettableFuture<String> nested = SettableFuture.create();
    assertTrue(future.setFuture(nested));
    // Later attempts to set the future should return false.
    assertFalse(future.set("x"));
    assertFalse(future.setException(new Exception("bar")));

		context.DeadlineExceeded, context.Canceled:
		return nil
	}
	return fmt.Errorf("unexpected type on 2nd nested level: %T", nestedErr)

third:
	if isPlatformError(nestedErr) {
		return nil
	}
	return fmt.Errorf("unexpected type on 3rd nested level: %T", nestedErr)
}

var dialErrorTests = []struct {
	network, address string
}{
	{"foo", ""},
	{"bar", "baz"},

    interface SerializationConstructor<T> {
        /**
         * Creates a new instance, using the given services and parameters. Uses the given instantiator to create nested objects, if required.
         */
        T newInstance(ServiceLookup services, InstanceGenerator nested) throws InvocationTargetException, IllegalAccessException, InstantiationException;
    }

    interface GeneratedConstructor<T> {
        /**

	// Payload {
	//  "exp": 4757607896,
	//  "iat": 1604007896,
	//  "iss": "******@****.***",
	//  "nested": {
	//    "key1": [
	//      "valueA",
	//      "valueB"
	//    ],
	//    "nested-2": {
	//      "key1": [
	//        "valueA",
	//        "valueB"
	//      ]
	//    }
	//  },
	//  "sub": "sub-1"
	// }

@UnsupportedWithConfigurationCache(because = "software model")
class ManagedTypeDslIntegrationTest extends AbstractIntegrationSpec {

    def "can configure a child of a managed type using a nested closure syntax"() {
        buildFile << '''
@Managed interface Person extends Named {
    Address getAddress()
}

@Managed interface Address {
    String getCity()
    void setCity(String s)
}

tasks.register('packageClasses', Zip) {
    archiveAppendix = "classes"
    destinationDirectory = archivesDirPath

    from compileJava
}
// end::link-task-properties[]

// tag::nested-specs[]
tasks.register('nestedSpecs', Copy) {
    into layout.buildDirectory.dir("explodedWar")
    exclude '**/*staging*'
    from('src/dist') {
        include '**/*.html', '**/*.png', '**/*.jpg'
    }

import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.AbstractSingleSymbolByPsiTest;
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;

Written by hand.
Test case for nested modules without an explicit relationship.
This is nested below the top-level module.

-- .mod --
module example.com/nest/sub
-- .info --
{"Version": "v1.0.0"}
-- go.mod --
module example.com/nest/sub
-- y/y.go --