var idxCb func() []byte
	if isCompressed {
		wantEncryption := crypto.Requested(r.Header) || isEncrypted
		s2c, cb := newS2CompressReader(reader, actualPartSize, wantEncryption)
		idxCb = cb
		defer s2c.Close()
		reader = etag.Wrap(s2c, reader)
		length = -1
	}

	srcInfo.Reader, err = hash.NewReader(ctx, reader, length, "", "", actualPartSize)
	if err != nil {

            this.headers = map;
        }
    }

    /**
     * Gets the headers of the response.
     *
     * @return the headers.
     */
    public Map<String, List<String>> getHeaders() {
        return headers;
    }

    /**
     * Gets the values of the specified header.
     *
     * @param name the name of the header.

	}

	// Initialize signature version '4' structured header.
	signV4Values := signValues{}

	var s3Err APIErrorCode
	// Save credential values.
	signV4Values.Credential, s3Err = parseCredentialHeader(strings.TrimSpace(credElement), region, stype)
	if s3Err != ErrNone {
		return sv, s3Err
	}

	// Save signed headers.
	signV4Values.SignedHeaders, s3Err = parseSignedHeader(authFields[1])

    static final long serialVersionUID = 1L;

    private transient Entry header = new Entry(null, null, null);

    private transient int size = 0;

    /**
     * Creates an {@link SLinkedList}.
     */
    public SLinkedList() {
        header.next = header;
        header.previous = header;
    }

    /**
     * Returns the first element.
     *
     * @return the first element

    val isUpgradeRequest =
      !hasRequestBody &&
        "upgrade".equals(request.header("Connection"), ignoreCase = true)
    try {
      exchange.writeRequestHeaders(request)

      if (hasRequestBody) {
        // If there's a "Expect: 100-continue" header on the request, wait for a "HTTP/1.1 100
        // Continue" response before transmitting the request body. If we don't get that, return

        byte[] header = buildHeader(NtStatus.NT_STATUS_INVALID_PARAMETER);
        byte[] body = buildErrorBody(2, 3, new byte[] { (byte) 0xAA, (byte) 0xBB, (byte) 0xCC });
        byte[] packet = new byte[header.length + body.length];
        System.arraycopy(header, 0, packet, 0, header.length);
        System.arraycopy(body, 0, packet, header.length, body.length);

        header.originalMessageSize = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // Skip reserved (2 bytes)
        bufferIndex += 2;

        // Read flags
        header.flags = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        // Read session ID
        header.sessionId = SMBUtil.readInt8(buffer, bufferIndex);

        return header;
    }

		ModTime: zipObjInfo.ModTime,
	}

	// Set standard object headers.
	if err = setObjectHeaders(ctx, w, objInfo, nil, opts); err != nil {
		writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
		return
	}

	// s3zip does not allow ranges.
	w.Header().Del(xhttp.AcceptRanges)

	// Set any additional requested response headers.
	setHeadGetRespHeaders(w, r.Form)

	// Successful response.

			// Lambda mock server
			lambdaServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set(xhttp.AmzRequestRoute, functionID)
				w.Header().Set(xhttp.AmzRequestToken, functionToken)
				w.Header().Set(xhttp.AmzFwdHeaderContentType, contentType)
				w.Header().Set(xhttp.AmzFwdStatus, strconv.Itoa(lambdaStatus))
				w.WriteHeader(lambdaStatus)
				w.Write([]byte(lambdaBody))
			}))

      for (pushPromise in promises) {
        val pushedHeaders = mutableListOf<Header>()
        pushedHeaders.add(Header(Header.TARGET_AUTHORITY, url(pushPromise.path).host))
        pushedHeaders.add(Header(Header.TARGET_METHOD, pushPromise.method))
        pushedHeaders.add(Header(Header.TARGET_PATH, pushPromise.path))
        val pushPromiseHeaders = pushPromise.headers
        for ((name, value) in pushPromiseHeaders) {