// Replace the body with a stripped one so the callbacks can't see real data.
      val response = response.stripBody()

      val reader = ServerSentEventReader(body.source(), this)
      try {
        if (!canceled) {
          listener.onOpen(this, response)
          while (!canceled && reader.processNextEvent()) {
          }
        }
      } catch (e: Exception) {
        val exception =
          when {

			return xl.versions[i].header.ModTime > xl.versions[j].header.ModTime
		}) {
			t.Errorf("Contents not sorted")
		}
		for i := range xl.versions {
			hdr := xl.versions[i].header
			ver, err := xl.getIdx(i)
			if err != nil {
				t.Error(err)
				continue
			}
			gotHdr := ver.header()
			if hdr != gotHdr {
				t.Errorf("Header does not match, index: %+v != meta: %+v", hdr, gotHdr)

	length      int64
}

// WarmBackend provides interface to be implemented by remote tier backends
type WarmBackend interface {
	Put(ctx context.Context, object string, r io.Reader, length int64) (remoteVersionID, error)
	PutWithMeta(ctx context.Context, object string, r io.Reader, length int64, meta map[string]string) (remoteVersionID, error)
	Get(ctx context.Context, object string, rv remoteVersionID, opts WarmBackendGetOpts) (io.ReadCloser, error)

	AmzFwdHeaderChecksumCrc32      = "x-amz-fwd-header-x-amz-checksum-crc32"
	AmzFwdHeaderChecksumCrc32c     = "x-amz-fwd-header-x-amz-checksum-crc32c"
	AmzFwdHeaderChecksumSha1       = "x-amz-fwd-header-x-amz-checksum-sha1"
	AmzFwdHeaderChecksumSha256     = "x-amz-fwd-header-x-amz-checksum-sha256"
	AmzFwdHeaderDeleteMarker       = "x-amz-fwd-header-x-amz-delete-marker"
	AmzFwdHeaderETag               = "x-amz-fwd-header-ETag"

        assertArrayEquals(testData, response.getData());
        // The decode method returns only the header size (16 bytes)\n        assertEquals(16, bytesDecoded);
    }

    @Test
    @DisplayName("Test decode without data")
    void testDecodeWithoutData() throws SMBProtocolDecodingException {
        // Prepare test data - only header, no data
        byte[] buffer = new byte[16];
        int bufferIndex = 0;

	lineNo    int
	lineStart int64
}

// NewDecoder creates new Decoder to read JSON values at the provided
// emitDepth from the provider io.Reader.
// If emitDepth is < 0, values at every depth will be emitted.
func NewDecoder(r io.Reader, emitDepth int) *Decoder {
	d := &Decoder{
		scanner:   newScanner(r),
		emitDepth: emitDepth,
		scratch:   &scratch{data: make([]byte, 1024)},

func HammerRWMutex(gomaxprocs, numReaders, numIterations int) {
	runtime.GOMAXPROCS(gomaxprocs)
	// Number of active readers + 10000 * number of active writers.
	var activity int32
	rwm := NewLRWMutex()
	cdone := make(chan bool)
	go writer(rwm, numIterations, &activity, cdone)
	var i int
	for i = 0; i < numReaders/2; i++ {
		go reader(rwm, numIterations, &activity, cdone)
	}
	go writer(rwm, numIterations, &activity, cdone)

                logger.debug("Apply header: key={}, value={}, mimeType={}", k, v, mimeType);
            }
            response.header(k, v);
        });
    }

    protected void adjustActionResponseHeaders(final String mimeType, final BiConsumer<String, String> callback) {
        defaultResponseHeaders.forEach(header -> callback.accept(header.getFirst(), header.getSecond()));

    // in combination with immutable cache entries, will ensure a thread-safe cache.
    CacheEntry<K, V> entry;

    // Check cache. We use == on purpose because it's cheaper and a cache miss is ok.
    entry = cacheEntry1;
    if (entry != null && entry.key == key) {
      return entry.value;
    }
    entry = cacheEntry2;
    if (entry != null && entry.key == key) {

    }

    @Override
    public String getSinkContents() throws IOException {
      File file = getFile();
      Reader reader = new InputStreamReader(new FileInputStream(file), UTF_8);
      StringBuilder builder = new StringBuilder();
      CharBuffer buffer = CharBuffer.allocate(100);
      while (reader.read(buffer) != -1) {
        Java8Compatibility.flip(buffer);
        builder.append(buffer);