parameters.getHeader().set(header);
                parameters.getPrefixHeaderFile().set(prefixHeaderFile);
            }
        });
    }

    @Input
    public String getHeader() {
        return header;
    }

    public void setHeader(String header) {
        this.header = header;
    }

    @OutputFile
    public File getPrefixHeaderFile() {

    public static void generatePrefixHeaderFile(List<String> headers, File headerFile) {
        if (!headerFile.getParentFile().exists()) {
            headerFile.getParentFile().mkdirs();
        }

        try {
            FileUtils.writeLines(headerFile, CollectionUtils.collect(headers, header -> {
                if (header.startsWith("<")) {
                    return "#include ".concat(header);
                } else {

                    task.from(library.getPublicHeaderFiles());
                    task.getDestinationDirectory().set(project.getLayout().getBuildDirectory().dir("headers"));
                    task.getArchiveClassifier().set("cpp-api-headers");
                    task.getArchiveFileName().set("cpp-api-headers.zip");
                });

		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.

	if err := delayResponse(r); err != nil {
		writeError(&body, "error delaying response error: "+err.Error())
	}

	// If the request has form ?headers=name:value[,name:value]* return those headers in response
	if err := setHeaderResponseFromHeaders(r, w); err != nil {
		writeError(&body, "response headers error: "+err.Error())
	}

	// If the request has form ?codes=code[:chance][,code[:chance]]* return those codes, rather than 200

      when:
        - key: "request.headers[X-header]"
          values: ["header", "header-prefix-*", "*-suffix-header", "*"]
          notValues: ["not-header", "not-header-prefix-*", "*-not-suffix-header", "*"]
        - key: "source.ip"
          values: ["10.10.10.10", "192.168.10.0/24"]
          notValues: ["90.10.10.10", "90.168.10.0/24"]

}

func GET(requestURL string, t time.Duration, headers map[string]string) (*bytes.Buffer, error) {
	return request("GET", requestURL, t, headers)
}

func PUT(requestURL string, t time.Duration, headers map[string]string) (*bytes.Buffer, error) {
	return request("PUT", requestURL, t, headers)
}

func request(method, requestURL string, t time.Duration, headers map[string]string) (*bytes.Buffer, error) {
	httpClient := &http.Client{

    - key: "source.ip"
      values: ["10.10.10.10"]
      notValues: ["20.20.20.20"]
  # L7 only when
  - when:
    - key: "connection.sni"
      values: [ "when-l7-sni"]
    - key: "request.headers[X-header]"

def test_get_item_header():
    response = client.get("/items-header/foo")
    assert response.status_code == 200, response.text
    assert response.json() == {"item": "The Foo Wrestlers"}


def test_get_item_not_found_header():
    response = client.get("/items-header/bar")
    assert response.status_code == 404, response.text
    assert response.headers.get("x-error") == "There goes my error"

   */
  private fun decodeHeaderAsJavaNetCookies(
    url: HttpUrl,
    header: String,
  ): List<Cookie> {
    val result = mutableListOf<Cookie>()
    var pos = 0
    val limit = header.length
    var pairEnd: Int
    while (pos < limit) {
      pairEnd = header.delimiterOffset(";,", pos, limit)
      val equalsSign = header.delimiterOffset('=', pos, pairEnd)