)

        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)

Test module containing a package that is also provided by a nested module tagged
with the same version.

-- .mod --
module example.net/ambiguous

go 1.16
-- .info --
{"Version": "v0.1.0"}
-- go.mod --
module example.net/ambiguous

go 1.16
-- nested/pkg/pkg.go --
// Package pkg exists in both example.net/ambiguous v0.1.0
// and example.net/ambiguous/nested v0.1.0

            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.

			DoRaw(context.TODO())
		if !apierrors.IsRequestEntityTooLargeError(err) {
			t.Errorf("expected too large error, got %v", err)
		}
	})

	// Create YAML just under 3MB limit, nested
	t.Run("create YAML doc under limit, nested", func(t *testing.T) {
		if testing.Short() {
			t.Skip("skipping expensive test")
		}
		yamlBody := []byte(fmt.Sprintf(`
	apiVersion: %s
	kind: %s
	metadata:
	  name: test

	conversion "k8s.io/apimachinery/pkg/conversion"
	node "k8s.io/kubernetes/pkg/apis/node"
)

// Convert_v1alpha1_RuntimeClass_To_node_RuntimeClass must override the automatic
// conversion since we unnested the spec struct after v1alpha1
func Convert_v1alpha1_RuntimeClass_To_node_RuntimeClass(in *v1alpha1.RuntimeClass, out *node.RuntimeClass, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta

		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)

        def absoluteNestedFile = new File(baseDir, 'child/nested').absoluteFile
        assertEquals("child${File.separator}nested".toString(), baseDirConverter.resolveAsRelativePath(absoluteNestedFile))
        assertEquals("child${File.separator}nested".toString(), baseDirConverter.resolveAsRelativePath(absoluteNestedFile.absolutePath))

        assertEquals("child${File.separator}nested".toString(), baseDirConverter.resolveForDisplay(absoluteNestedFile))