case fs.ModeNamedPipe:
		m = s_IFIFO
	case fs.ModeSocket:
		m = s_IFSOCK
	case fs.ModeDevice:
		m = s_IFBLK
	case fs.ModeDevice | fs.ModeCharDevice:
		m = s_IFCHR
	}
	if mode&fs.ModeSetuid != 0 {
		m |= s_ISUID
	}
	if mode&fs.ModeSetgid != 0 {
		m |= s_ISGID
	}
	if mode&fs.ModeSticky != 0 {
		m |= s_ISVTX
	}
	return m | uint32(mode&0777)
}

    Files.createDirectory(fs.getPath("dir/e"));
    Files.createSymbolicLink(fs.getPath("dir/f"), fs.getPath("/dontdelete"));
    Files.createFile(fs.getPath("dir/b/g"));
    Files.createSymbolicLink(fs.getPath("dir/b/h"), fs.getPath("../a"));
    Files.createFile(fs.getPath("dir/b/i/j/k"));
    Files.createDirectory(fs.getPath("/dontdelete"));
    Files.createFile(fs.getPath("/dontdelete/a"));

	switch m := fs.FileMode(fi.h.Mode) &^ 07777; m {
	case c_ISDIR:
		mode |= fs.ModeDir
	case c_ISFIFO:
		mode |= fs.ModeNamedPipe
	case c_ISLNK:
		mode |= fs.ModeSymlink
	case c_ISBLK:
		mode |= fs.ModeDevice
	case c_ISCHR:
		mode |= fs.ModeDevice
		mode |= fs.ModeCharDevice
	case c_ISSOCK:
		mode |= fs.ModeSocket
	}

	switch fi.h.Typeflag {
	case TypeSymlink:
		mode |= fs.ModeSymlink

    Files.createDirectory(fs.getPath("dir/e"));
    Files.createSymbolicLink(fs.getPath("dir/f"), fs.getPath("/dontdelete"));
    Files.createFile(fs.getPath("dir/b/g"));
    Files.createSymbolicLink(fs.getPath("dir/b/h"), fs.getPath("../a"));
    Files.createFile(fs.getPath("dir/b/i/j/k"));
    Files.createDirectory(fs.getPath("/dontdelete"));
    Files.createFile(fs.getPath("/dontdelete/a"));

	// We are expecting at most 1 calls to the mock, wait for them
	wg, waitForMockCalls := NewWaitForNCalls(t, 1)

	fs := &fakeServer{testWG: wg}

	fs.On("AddPodToMesh",
		ctx,
		mock.IsType(pod),
		util.GetPodIPsIfPresent(pod),
		"",
	).Return(nil)

	server := getFakeDP(fs, client.Kube())

	fs.Start(ctx)
	handlers := setupHandlers(ctx, client, server, "istio-system")
	client.RunAndWait(ctx.Done())

	return nil
}

func fakeFs() fs.FS {
	subFs, err := fs.Sub(fakeProc, "testdata")
	if err != nil {
		panic(err)
	}
	subFs, err = fs.Sub(subFs, "cgroupns")
	if err != nil {
		panic(err)
	}
	return &fakeFsWithFakeFds{ReadDirFS: subFs.(fs.ReadDirFS)}
}

type fakeFsWithFakeFds struct {
	fs.ReadDirFS
}
type fakeFileFakeFds struct {
	fs.File
	fd uintptr
}

	// We are expecting at most 1 calls to the mock, wait for them
	wg, waitForMockCalls := NewWaitForNCalls(t, 1)
	fs := &fakeServer{testWG: wg}

	fs.On("AddPodToMesh",
		ctx,
		mock.IsType(pod),
		util.GetPodIPsIfPresent(pod),
		valid.Netns,
	).Return(nil)

	dpServer := getFakeDP(fs, client.Kube())

	handlers := setupHandlers(ctx, client, dpServer, "istio-system")

// using the semantics of fs.FS.Open:
// paths are always slash separated, with no
// leading / or ../ elements.
func (r *Reader) Open(name string) (fs.File, error) {
	r.initFileList()

	if !fs.ValidPath(name) {
		return nil, &fs.PathError{Op: "open", Path: name, Err: fs.ErrInvalid}
	}
	e := r.openLookup(name)
	if e == nil {
		return nil, &fs.PathError{Op: "open", Path: name, Err: fs.ErrNotExist}
	}

import static org.junit.jupiter.api.Assertions.assertThrows;

class MavenPropertiesLoaderTest {

    @Test
    void testIncludes() throws Exception {
        FileSystem fs = Jimfs.newFileSystem(Configuration.unix());

        Path mavenHome = fs.getPath("/maven");
        Files.createDirectories(mavenHome);
        Path mavenConf = mavenHome.resolve("conf");
        Files.createDirectories(mavenConf);

			ModTime:  time.Unix(1360600852, 0),
			Typeflag: TypeSymlink,
		},
		fm: 0777 | fs.ModeSymlink,
	}, {
		// character device node.
		h: &Header{
			Name:     "dev/null",
			Mode:     0666,
			Size:     0,
			ModTime:  time.Unix(1360578951, 0),
			Typeflag: TypeChar,
		},
		fm: 0666 | fs.ModeDevice | fs.ModeCharDevice,
	}, {
		// block device node.
		h: &Header{
			Name:     "dev/sda",