getwdCache.Unlock()
	if len(dir) > 0 {
		d, err := statNolog(dir)
		if err == nil && SameFile(dot, d) {
			return dir, nil
		}
	}

	// Root is a special case because it has no parent
	// and ends in a slash.
	root, err := statNolog("/")
	if err != nil {
		// Can't stat root - no hope.
		return "", err
	}
	if SameFile(root, dot) {
		return "/", nil
	}

	// General algorithm: find name in parent

// SameFile reports whether fi1 and fi2 describe the same file.
// For example, on Unix this means that the device and inode fields
// of the two underlying structures are identical; on other systems
// the decision may be based on the path names.
// SameFile only applies to results returned by this package's [Stat].
// It returns false in other cases.
func SameFile(fi1, fi2 FileInfo) bool {

		t.Error(err)
		return
	}
	params.statCheck(t, path, sfi2)

	if !os.SameFile(sfi, sfi2) {
		t.Errorf("stat of open %q file and stat of %q should be the same", path, path)
	}

	if params.isLink {
		if os.SameFile(sfi2, lsfi) {
			t.Errorf("stat of opened %q file and lstat of %q should not be the same", path, path)
		}
	} else {
		if !os.SameFile(sfi2, lsfi) {

}

func validNewEvent(namespace string) *api.Event {
	someTime := metav1.MicroTime{Time: time.Unix(1505828956, 0)}
	return &api.Event{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo",
			Namespace: namespace,
		},
		InvolvedObject: api.ObjectReference{
			Name:      "bar",
			Namespace: namespace,
		},
		EventTime:           someTime,
		ReportingController: "test-controller",

		t.Fatalf("Child returned %q, want an absolute path", out)
	}
	if !sameFile(outs, ep) {
		t.Fatalf("Child returned %q, not the same file as %q", out, ep)
	}
}

func sameFile(fn1, fn2 string) bool {
	fi1, err := os.Stat(fn1)
	if err != nil {
		return false
	}
	fi2, err := os.Stat(fn2)
	if err != nil {
		return false
	}
	return os.SameFile(fi1, fi2)
}

func init() {

            {{- range $index, $container := .Spec.Containers }}
            - name: {{ $container.Name }}
              env:
              - name: SOME_ENV
                value: "true"
              - name: SOME_FILE
                value: /var/lib/data/foo.json
              volumeMounts:
              - mountPath: /var/lib/data/foo.json
                subPath: foo.json
                name: some-injected-file
            {{- end}}

func (d *dirInfo) init(h syscall.Handle) {
	d.h = h
	d.class = windows.FileFullDirectoryRestartInfo
	// The previous settings are enough to read the directory entries.
	// The following code is only needed to support os.SameFile.

	// It is safe to query d.vol once and reuse the value.
	// Hard links are not allowed to reference files in other volumes.
	// Junctions and symbolic links can reference files and directories in other volumes,

      creationTimestamp: null
      labels:
        app: hello
    spec:
      containers:
      - env:
        - name: SOME_ENV
          value: "true"
        - name: SOME_FILE
          value: /var/lib/data/foo.json
        image: fake.docker.io/google-samples/hello-go-gke:1.0
        name: hello
        readinessProbe:
          httpGet:
            port: 80
        resources: {}

func (fs *fileStat) Mode() FileMode     { return fs.mode }
func (fs *fileStat) ModTime() time.Time { return fs.modTime }
func (fs *fileStat) Sys() any           { return &fs.sys }

func sameFile(fs1, fs2 *fileStat) bool {
	return fs1.sys.Dev == fs2.sys.Dev && fs1.sys.Ino == fs2.sys.Ino

    }

    def "has consistent uuid for same file"() {
        when:
        def file = new File("foo")
        def sameFile = new File("foo")
        def differentFile = new File("bar")

        then:
        getUUID(file) == getUUID(sameFile)
        getUUID(file) != getUUID(differentFile)
    }