Ian Lance Taylor <******@****.***> 1618865513 -0700

        assertEquals(path.normalize(), source.getPath());
        assertEquals(path.toString(), source.getLocation());

        Source resolved = source.resolve("subdir");
        assertNotNull(resolved);
        assertEquals(path.resolve("subdir").normalize(), resolved.getPath());
    }

    @Test
    void testBuildPathSourceFunctionality() {
        // Test build source functionality

		)
		if err != nil {
			return "", err
		}
	}

	return finalPkgpath, nil
}

// subdir determines the package based on the current working directory,
// and returns the path to the package source relative to $GOROOT (or $GOPATH).
func subdir() (pkgpath string, underGoRoot bool, err error) {
	cwd, err := os.Getwd()
	if err != nil {
		return "", false, err
	}

     */
    @Test
    public void testIsPathSafe_PathInsideBase() throws Exception {
        final Path baseDir = tempFolder.getRoot().toPath();
        final Path subDir = Files.createDirectory(baseDir.resolve("subdir"));
        final Path file = Files.createFile(subDir.resolve("test.txt"));

        assertTrue("Path inside base should be allowed", FileUtil.isPathSafe(file, baseDir));
    }

    /**

}

// adbCopyTree copies testdata, go.mod, go.sum files from subdir
// and from parent directories all the way up to the root of subdir.
// go.mod and go.sum files are needed for the go tool modules queries,
// and the testdata directories for tests.  It is common for tests to
// reach out into testdata from parent packages.
func adbCopyTree(deviceCwd, subdir string) error {
	dir := ""
	for {

        String childUrl1 = ftpInfo.toChildUrl("file.txt");
        assertEquals("ftp://example.com/parent/file.txt", childUrl1);

        String childUrl2 = ftpInfo.toChildUrl("subdir/file.txt");
        assertEquals("ftp://example.com/parent/subdir/file.txt", childUrl2);

        // Test that the method properly handles various child paths
        FtpInfo ftpInfo2 = new FtpClient.FtpInfo("ftp://example.com/test", Constants.UTF_8);

        file1.close();

        SmbFile file2 = new SmbFile(dirPath + "file2.txt", fileContext);
        file2.createNewFile();
        file2.close();

        SmbFile subdir = new SmbFile(dirPath + "subdir/", fileContext);
        subdir.mkdir();
        subdir.close();
        Thread.sleep(200);

        // Test string array listing with fresh context
        CIFSContext listContext = createFreshContext();

        assertFalse(it.hasNext(), "Iterator exhausted after valid entries");
        verify(tree, times(1)).release(); // closed after exhaustion
    }

    @ParameterizedTest
    @ValueSource(strings = { "", "file.txt", "subdir" })
    @DisplayName("Name filter interaction: accept calls and rejections")
    void nameFilterAccepts(String acceptedName) throws Exception {
        // Arrange
        stubAcquireReturnsSelf();

	}{
		{
			file: "testdata/unix.zip",
			want: []string{".", "dir", "dir/bar", "dir/empty", "hello", "readonly"},
		},
		{
			file: "testdata/subdir.zip",
			want: []string{".", "a", "a/b", "a/b/c"},
		},
		{
			file:    "testdata/dupdir.zip",
			wantErr: true,
		},
	} {
		t.Run(test.file, func(t *testing.T) {
			t.Parallel()
			z, err := OpenReader(test.file)
			if err != nil {

for 'xl.meta' files. Wildcards are accepted: 'testdir/*.txt' will compress
all files in testdir ending with '.txt', directories can be wildcards
as well. 'testdir/*/*.txt' will match 'testdir/subdir/b.txt', double stars
means full recursive. 'testdir/**/xl.meta' will search for all xl.meta
recursively.

FLAGS:
  {{range .VisibleFlags}}{{.}}
  {{end}}
`
	//nolint:staticcheck