wg.Wait()
	unixln.Close()
}

func TestAbsWithSlash(t *testing.T) {
	// On Windows, filepath.IsAbs will not return True for paths prefixed with a slash
	assert.True(t, IsAbs("/test"))
	assert.True(t, IsAbs("\\test"))

	assert.False(t, IsAbs("./local"))
	assert.False(t, IsAbs("local"))

		return false, fmt.Errorf("stat file %s failed: %v", filePath, err)
	}
	if fi.Mode()&os.ModeSocket == 0 {
		return false, nil
	}
	return true, nil
}

// IsAbs is same as filepath.IsAbs on Unix.
func IsAbs(path string) bool {
	return filepath.IsAbs(path)

}

func localize(path string) (string, error) {
	if path[0] == '#' || bytealg.IndexByteString(path, 0) >= 0 {
		return "", errInvalidPath
	}
	return path, nil
}

// IsAbs reports whether the path is absolute.
func IsAbs(path string) bool {
	return stringslite.HasPrefix(path, "/") || stringslite.HasPrefix(path, "#")
}

// volumeNameLen returns length of the leading volume name on Windows.
// It returns 0 elsewhere.

	return unixIsLocal(path)
}

func localize(path string) (string, error) {
	if bytealg.IndexByteString(path, 0) >= 0 {
		return "", errInvalidPath
	}
	return path, nil
}

// IsAbs reports whether the path is absolute.
func IsAbs(path string) bool {
	return stringslite.HasPrefix(path, "/")
}

// volumeNameLen returns length of the leading volume name on Windows.
// It returns 0 elsewhere.

			"filePath", filePath, "lastSocketErr", lastSocketErr, "err", err)
		return false, nil
	}
	return true, nil
}

// IsAbs returns whether the given path is absolute or not.
// On Windows, filepath.IsAbs will not return True for paths prefixed with a slash, even
// though they can be used as absolute paths (https://docs.microsoft.com/en-us/dotnet/standard/io/file-path-formats).
//

	// nodes, it would contain absolute paths that may lack drive letters, since the config
	// could have been generated on a Linux control-plane node. On Windows the
	// Golang filepath.IsAbs() function returns false unless the path contains a drive letter.
	// This trips client-go and the kubelet, creating problems on Windows nodes.
	// Fixing it in client-go or the kubelet is a breaking change to existing Windows

// EvalSymlinks calls [Clean] on the result.
func EvalSymlinks(path string) (string, error) {
	return evalSymlinks(path)
}

// IsAbs reports whether the path is absolute.
func IsAbs(path string) bool {
	return filepathlite.IsAbs(path)
}

// Abs returns an absolute representation of path.
// If the path is not absolute it will be joined with the current

			return "", &Error{file, err}
		}
	}

	path := os.Getenv("path")
	for _, dir := range filepath.SplitList(path) {
		path := filepath.Join(dir, file)
		if err := findExecutable(path); err == nil {
			if !filepath.IsAbs(path) {
				if execerrdot.Value() != "0" {
					return path, &Error{file, ErrDot}
				}
				execerrdot.IncNonDefault()
			}
			return path, nil
		}
	}
	return "", &Error{file, ErrNotFound}
}

		for _, test := range isabstests {
			tests = append(tests, IsAbsTest{"c:" + test.path, test.isAbs})
		}
	} else {
		tests = isabstests
	}

	for _, test := range tests {
		if r := filepath.IsAbs(test.path); r != test.isAbs {
			t.Errorf("IsAbs(%q) = %v, want %v", test.path, r, test.isAbs)
		}
	}
}

type EvalSymlinksTest struct {

		if dir == "" {
			// Unix shell semantics: path element "" means "."
			dir = "."
		}
		path := filepath.Join(dir, file)
		if err := findExecutable(path); err == nil {
			if !filepath.IsAbs(path) {
				if execerrdot.Value() != "0" {
					return path, &Error{file, ErrDot}
				}
				execerrdot.IncNonDefault()
			}
			return path, nil
		}
	}
	return "", &Error{file, ErrNotFound}
}