cache.close()
    createNewCacheWithSize(10)
    set("a", "a", "a")
    set("b", "b", "b")
    set("c", "c", "c")
    set("d", "d", "d")
    set("e", "e", "e")
    cache["b"]!!.close() // 'B' is now least recently used.

    // Causing the size to grow to 12 should evict 'A'.
    set("f", "f", "f")
    // Causing the size to grow to 12 should evict 'C'.
    set("g", "g", "g")
    cache.flush()

query.highlight.encoder=default
query.highlight.force.source=false
query.highlight.fragmenter=span
query.highlight.fragment.offset=-1
query.highlight.no.match.size=0
query.highlight.order=score
query.highlight.phrase.limit=256
query.highlight.content.description.fields=hl_content,digest
query.highlight.boundary.position.detect=true
query.highlight.text.fragment.type=query
query.highlight.text.fragment.size=3

   * and accesses that were performed on the map. The queue is drained on writes and when it exceeds
   * its capacity threshold.
   *
   * The Least Recently Used page replacement algorithm was chosen due to its simplicity, high hit
   * rate, and ability to be implemented with O(1) time complexity. The initial LRU implementation

				"application/vnd.yamaha.hv-voice",
				"application/vnd.yamaha.openscoreformat",
				"application/vnd.yamaha.openscoreformat.osfpvg+xml",
				"application/vnd.yamaha.smaf-audio",
				"application/vnd.yamaha.smaf-phrase",
				"application/vnd.yellowriver-custom-menu",
				"application/vnd.zul",
				"application/vnd.zzazz.deck+xml",
				"application/voicexml+xml",
				"application/watcherinfo+xml",
				"application/whoispp-query",

 * ```
 *
 * ## Shutdown Isn't Necessary
 *
 * The threads and connections that are held will be released automatically if they remain idle. But
 * if you are writing a application that needs to aggressively release unused resources you may do
 * so.
 *
 * Shutdown the dispatcher's executor service with [shutdown()][ExecutorService.shutdown]. This will
 * also cause future calls to the client to be rejected.
 *
 * ```java

   * mode}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754
   * default rounding mode: if the two nearest representable values are equally near, the one with
   * the least significant bit zero is chosen. (In such cases, both of the nearest representable
   * values are even integers; this method returns the one that is a multiple of a greater power of
   * two.)
   *

	"testing"
	"time"
)

func TestReader(t *testing.T) {
	vectors := []struct {
		file    string    // Test input file
		headers []*Header // Expected output headers
		chksums []string  // CRC32 checksum of files, leave as nil if not checked
		err     error     // Expected error to occur
	}{{
		file: "testdata/gnu.tar",
		headers: []*Header{{
			Name:     "small.txt",
			Mode:     0640,
			Uid:      73025,
			Gid:      5000,

        final Number primaryTerm = (Number) source.remove(fessConfig.getIndexFieldPrimaryTerm());
        IndexResponse response;
        try {
            if (id == null) {
                // TODO throw Exception in next release
                // create
                response = client.prepareIndex().setIndex(index).setSource(new DocMap(source)).setRefreshPolicy(RefreshPolicy.IMMEDIATE)

		return
	}

	if currentReleaseTime.IsZero() || currentReleaseTime.Equal(timeSentinel) {
		apiErr := errorCodes.ToAPIErr(ErrMethodNotAllowed)
		apiErr.Description = fmt.Sprintf("unable to perform in-place update, release time is unrecognized: %s", currentReleaseTime)
		writeErrorResponseJSON(ctx, w, apiErr, r.URL)
		return
	}

	vars := mux.Vars(r)
	updateURL := vars["updateURL"]
	dryRun := r.Form.Get("dry-run") == "true"

   * }</pre>
   *
   * <p>Any structural changes to the underlying iteration (aside from those performed by the
   * iterator's own {@link PeekingIterator#remove()} method) will leave the iterator in an undefined
   * state.
   *
   * <p>The returned iterator does not support removal after peeking, as explained by {@link
   * PeekingIterator#remove()}.
   *