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:
## In OSX, 'sort -V' option does not exist, hence
## we have our own version compare function.

                }
            }
        }

        return abbreviateSite(url);
    }

    /**
     * Puts data into the result data map, handling value appending if configured.
     * If data appending is enabled and the key already exists, values are combined into arrays.
     *
     * @param dataMap the data map to modify
     * @param key the key to store the value under

[Snapshot API Diffs][guava-snapshot-api-diffs] are also available.

Another easy way to get to the Javadoc is to open
[guava.dev/api](https://guava.dev/api). You can also jump right to a specific
class by appending the class name to guava.dev. For example,
[guava.dev/ImmutableList](https://guava.dev/ImmutableList)!

## Learn about Guava

-   Our users' guide, [Guava Explained]

* `media_type` - A `str` giving the media type. E.g. `"text/html"`.

FastAPI (actually Starlette) will automatically include a Content-Length header. It will also include a Content-Type header, based on the `media_type` and appending a charset for text types.

{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}

### `HTMLResponse` { #htmlresponse }

Takes some text or bytes and returns an HTML response, as you read above.

     * Allows different search configurations based on the request host.
     */
    @Size(max = 10000)
    public String virtualHostValue;

    /**
     * Enable or disable appending query parameters to search URLs.
     * When enabled, additional parameters are added to search result URLs.
     */
    @Size(max = 10)
    public String appendQueryParameter;

    /**

//	 e2 := MD5(part-2)
//	...
//	 eN := MD5(part-N)
//
// Then, the ETag of the object is computed as MD5 of all individual
// part checksums. S3 also encodes the number of parts into the ETag
// by appending a -<number-of-parts> at the end:
//
//	ETag := MD5(e1 || e2 || e3 ... || eN) || -N
//
//	For example: ceb8853ddc5086cc4ab9e149f8f09c88-5
//
// However, this scheme is only used for multipart objects that are

	{"\xff-\xff", "-", -1, []string{"\xff", "\xff"}},
}

func TestSplit(t *testing.T) {
	for _, tt := range splittests {
		a := SplitN([]byte(tt.s), []byte(tt.sep), tt.n)

		// Appending to the results should not change future results.
		var x []byte
		for _, v := range a {
			x = append(v, 'z')
		}

		result := sliceOfString(a)
		if !slices.Equal(result, tt.a) {

   *       #copyTo(CharSink)}. We know this is correct since strings are immutable and so the length
   *       can't change, and it is faster because many writers and appendables are optimized for
   *       appending string instances.
   * </ul>
   */
  private static class StringCharSource extends CharSequenceCharSource {
    StringCharSource(String seq) {
      super(seq);
    }

    @Override

     *
     * @return whether DFS lookup is disabled
     */
    boolean isDfsDisabled();

    /**
     * Enable hack to make kerberos auth work with DFS sending short names
     *
     * This works by appending the domain name to the netbios short name and will fail horribly if this mapping is not
     * correct for your domain.
     *
     * Property {@code jcifs.smb.client.dfs.convertToFQDN} (boolean, default false)
     *

	n := testing.AllocsPerRun(100, func() {
		got.Reset()
		for i := 0; i < 1000; i++ {
			b := got.AvailableBuffer()
			b = strconv.AppendInt(b, int64(i), 10)
			got.Write(b)
		}
	})
	if n > 0 {
		t.Errorf("allocations occurred while appending")
	}
}

func TestRuneIO(t *testing.T) {
	const NRune = 1000
	// Built a test slice while we write the data
	b := make([]byte, utf8.UTFMax*NRune)
	var buf Buffer