createDirs("a", "nested")
        settingsFile << """
            include "a"
            includeBuild "nested"

            rootProject.name = "root"
            rootProject.buildFileName = 'root.gradle'

        """

        def nestedSettingsFile = file("nested/settings.gradle")
        nestedSettingsFile << """
            rootProject.name = "nested"
        """

            }

            class DefaultCompositeModel implements java.io.Serializable {
                private final DefaultModel nested
                DefaultCompositeModel(DefaultModel nested) { this.nested = nested }
                BaseModel getNested() { nested }
            }
        """
    }

    def "supports model polymorphism"() {
        given:

      notValues: ["not-iss", "not-iss-prefix-*", "*-not-suffix-iss", "*"]
  - when:
    - key: "request.auth.claims[nested1][nested2]"
      values: ["nested", "nested-prefix-*", "*-suffix-nested", "*"]
      notValues: ["not-nested", "not-nested-prefix-*", "*-not-suffix-nested", "*"]
  - when:
    - key: "destination.ip"
      values: ["10.10.10.10", "192.168.10.0/24"]
      notValues: ["90.10.10.10", "90.168.10.0/24"]
  - when:

        )

        assertClassFilePathCandidatesFor(
            "foo.My.Nested",
            listOf(
                "foo/My/Nested.class", "foo/My/NestedKt.class",
                "foo/My${'$'}Nested.class", "foo/My${'$'}NestedKt.class",
                "foo${'$'}My${'$'}Nested.class", "foo${'$'}My${'$'}NestedKt.class"
            )
        )
    }

    private

        def file2 = tmpDir.file('different/nested/jar2.jar')

        then:
        ManifestUtil.createManifestClasspath(jarFile, [file1, file2]) == "${tmpDirPath}different/jar1.jar ${tmpDirPath}different/nested/jar2.jar"
    }

    def "url encodes spaces in manifest classpath"() {
        when:
        def classpathFiles = [tmpDir.file('mydir/jar one.jar'), tmpDir.file('mydir/nested dir/jar two.jar')]

        then:

        outputContains("Hello from root build's plugin")
    }

    @ToBeFixedForConfigurationCache
    def "prefers a source mapping defined in the root build to one defined in a nested build when the nested build requests plugins"() {
        given:
        vcsMapping('org.test:first', first)
        // root build does not inject any plugins to second
        vcsMapping('org.test:second', second)

            action.run()
        }

        !models.mayRunInParallel
        models.projects.path == [':', ':a', ':b']
    }

    @TargetGradleVersion(">=3.4")
    def "nested action can run further nested actions"() {
        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
        """
        buildFile << """
            allprojects {

        getCallableSymbols(names.toList())

    /**
     * Return a sequence of [KaClassifierSymbol] which current scope contain if classifier name matches [nameFilter]. The sequence includes:
     * nested classes, inner classes, nested type aliases for the class scope, and top-level classes and top-level type aliases for file scope.
     *
     * This function needs to retrieve a set of all possible names before processing the scope.

		t.Fatalf("Should find saved record")
	}
}

func TestNestedTransactionWithBlock(t *testing.T) {
	var (
		user  = *GetUser("transaction-nested", Config{})
		user1 = *GetUser("transaction-nested-1", Config{})
		user2 = *GetUser("transaction-nested-2", Config{})
	)

	if err := DB.Transaction(func(tx *gorm.DB) error {
		tx.Create(&user)

          "name": "instance",
          "unspecified": "bar"
        },
        "spec": {
        }
      }
    }
  }
}
`, expectedPruned: []string{"nested.spec.embedded.spec.unspecified", "nested.spec.embedded.unspecified", "nested.spec.unspecified", "nested.unspecified", "pruned.spec.unspecified", "pruned.unspecified", "unspecified"}},
		{name: "x-kubernetes-embedded-resource, with root=true", json: `
{
  "apiVersion": "foo/v1",