}

    def "can define task with abstract read-only @Nested property"() {
        given:
        buildFile << """
            interface Params {
                @Input
                Property<Integer> getCount()
            }
            abstract class MyTask extends DefaultTask {
                @Nested
                abstract Params getParams()

                @TaskAction

                @Internal
                Property<String> getUnused()
            }

            abstract class SomeTask extends DefaultTask {
                @Nested
                abstract Bean getBean()

                @Nested
                abstract Bean getUnusedBean()

                @Internal
                abstract Property<String> getValue()

                @Internal

        "top-level property has convention, nested is set" | setId("convention")                | setFooBar("baz")      | """id = convention\nbar = baz"""
        "nested property has convention and is set"        | setFooBar("convention")            | setFooBar("baz")      | """id = <no id>\nbar = baz"""

	users := []User{
		{
			Name: "nested-joins-1",
			Manager: &User{
				Name: "nested-joins-manager-1",
				Company: Company{
					Name: "nested-joins-manager-company-1",
				},
				NamedPet: &Pet{
					Name: "nested-joins-manager-namepet-1",
					Toy: Toy{
						Name: "nested-joins-manager-namepet-toy-1",
					},
				},
			},

    expectedWithoutNull:
      nonNilKey1: foo
      nonNilKey2: bar
  - description: nested map
    originalObj:
      mapKey:
        nilKey: null
        nonNilKey: foo
    expectedWithNull:
      mapKey:
        nilKey: null
    expectedWithoutNull:
      mapKey:
        nonNilKey: foo
  - description: nested map that all subkeys are nil
    originalObj:
      mapKey:
        nilKey1: null

            'nested.outputDirectory': annotationInvalidInContext { annotation('OutputDirectory').includeLink() },
            'nested.inputFile': missingNormalizationStrategy { annotatedWith('InputFile').includeLink().noIntro() },
            'nested.stringProperty': missingAnnotationMessage { property('nested.stringProperty').missingInput().includeLink().noIntro() },

            try (PreparedStatement testIdsStatement = connection.prepareStatement(
                "select testClass, testId, testProject" +
                    "   from testExecutionExperiment" +
                    "  where resultType = ?" +
                    "  order by testClass, testId, testProject")
            ) {
                testIdsStatement.setString(1, resultType);

func settingsFn(s *resource.Settings) func(string) (*resource.Settings, error) {
	return func(testID string) (*resource.Settings, error) {
		s.TestID = testID
		s.BaseDir = os.TempDir()
		return s, nil
	}
}

func defaultSettingsFn(testID string) (*resource.Settings, error) {
	s := resource.DefaultSettings()
	s.TestID = testID
	s.BaseDir = os.TempDir()

	return s, nil
}

func cleanupRT() {
	rtMu.Lock()

            import org.gradle.api.tasks.Nested;

            import javax.inject.Inject;

            @Restricted
            public abstract class AnotherSoftwareTypeExtension {
                @Inject
                public AnotherSoftwareTypeExtension() { }

                @Restricted
                public abstract Property<String> getFoo();

                @Nested
                public abstract Bar getBar();

        ]
        def addProjectListeners = { String source ->
            """
            project.afterEvaluate {
                println "project.afterEvaluate(Closure) from $source"
                project.afterEvaluate {
                    println "nested project.afterEvaluate(Closure) from $source"
                    project.afterEvaluate {