* the original.
     *
     * @return The canonicalized URL of this SMB resource.
     */
    String getCanonicalURL ();


    /**
     * @return The canonicalized UNC path of this SMB resource (relative to it's share)
     */
    String getUNCPath ();


    /**
     * @return The canonicalized URL path (relative to the server/domain)
     */
    String getURLPath ();

// The key is case insensitive; it is canonicalized by
// [CanonicalHeaderKey].
func (h Header) Add(key, value string) {
	textproto.MIMEHeader(h).Add(key, value)
}

// Set sets the header entries associated with key to the
// single element value. It replaces any existing values
// associated with key. The key is case insensitive; it is
// canonicalized by [textproto.CanonicalMIMEHeaderKey].

### New unique package

The new [unique] package provides facilities for
canonicalizing values (like "interning" or "hash-consing").

Any value of comparable type may be canonicalized with the new
`Make[T]` function, which produces a reference to a canonical copy of
the value in the form of a `Handle[T]`.
Two `Handle[T]` are equal if and only if the values used to produce the
handles are equal, allowing programs to deduplicate values and reduce

		if s := CanonicalMIMEHeaderKey(tt.in); s != tt.out {
			t.Errorf("CanonicalMIMEHeaderKey(%q) = %q, want %q", tt.in, s, tt.out)
		}
	}
}

// Issue #34799 add a Header method to get multiple values []string, with canonicalized key
func TestMIMEHeaderMultipleValues(t *testing.T) {
	testHeader := MIMEHeader{
		"Set-Cookie": {"cookie 1", "cookie 2"},
	}
	values := testHeader.Values("set-cookie")
	n := len(values)
	if n != 2 {

// The resulting tag is canonicalized using the canonicalization type c.
func (c CanonType) Parse(s string) (t Tag, err error) {
	defer func() {
		if recover() != nil {
			t = Tag{}
			err = language.ErrSyntax
		}
	}()

	tt, err := language.Parse(s)
	if err != nil {
		return makeTag(tt), err
	}
	tt, changed := canonicalize(c, tt)
	if changed {
		tt.RemakeString()
	}

	# Iterate down a (possible) chain of symlinks
	while [ -L "$TARGET_FILE" ]; do
		TARGET_FILE=$(env readlink $TARGET_FILE)
		cd $(dirname $TARGET_FILE)
		TARGET_FILE=$(basename $TARGET_FILE)
	done

	# Compute the canonicalized name by finding the physical path
	# for the directory we're in and appending the target file.
	PHYS_DIR=$(pwd -P)
	RESULT=$PHYS_DIR/$TARGET_FILE
	echo $RESULT
}

## FIXME:

     * Therefore, we disable file system watching when we try to watch a directory whose parent is a symlink.
     *
     * Note that the project directory is canonicalized by Gradle, so the project directory can always be watched.
     */
    private static void validateLocationToWatch(File location) {
        try {
            String canonicalPath = location.getCanonicalPath();

     *
     * <p>The daemons will use this information to update the retained file system state.
     *
     * <p>The paths which are passed in need to be absolute, canonicalized paths.
     * For a delete, the deleted path should be passed.
     * For a rename, the old and the new path should be passed.
     * When creating a new file, the path to the file should be passed.
     *

			},
			expectPodUID:      "2c48913c-b29f-11e7-9350-020968147796",
			expectContainerID: "9bca8d63d5fa610783847915bcff0ecac1273e5b4bed3f6fa1b07350e0135961",
		},
		{
			name: "pod UID canonicalized",
			cgroupPaths: []string{
				"/user.slice",
				"/kubepods/pod2c48913c_b29f_11e7_9350_020968147796/9bca8d63d5fa610783847915bcff0ecac1273e5b4bed3f6fa1b07350e0135961",
			},

//
// HasFilePathPrefix is case-sensitive (except for volume names) even if the
// filesystem is not, does not apply Unicode normalization even if the
// filesystem does, and assumes that all path separators are canonicalized to
// filepath.Separator (as returned by filepath.Clean).
func HasFilePathPrefix(s, prefix string) bool {
	sv := filepath.VolumeName(s)
	pv := filepath.VolumeName(prefix)