var noTransform = false
  var immutable = false

  var canUseHeaderValue = true
  var headerValue: String? = null

  loop@ for (i in 0 until headers.size) {
    val name = headers.name(i)
    val value = headers.value(i)

    when {
      name.equals("Cache-Control", ignoreCase = true) -> {
        if (headerValue != null) {
          // Multiple cache-control headers means we can't use the raw value.

	return len(s) >= len(prefix) && strings.EqualFold(s[:len(prefix)], prefix)
}

func headerValue(h http.Header, headerNames []string) string {
	for _, headerName := range headerNames {
		headerValue := h.Get(headerName)
		if len(headerValue) > 0 {
			return headerValue
		}
	}
	return ""
}

func allHeaderValues(h http.Header, headerNames []string) []string {
	ret := []string{}

		g.Expect(r.RequestHeadersToAdd).To(Equal([]*envoycore.HeaderValueOption{
			{
				Header: &envoycore.HeaderValue{
					Key:   "x-req-set",
					Value: "v1",
				},
				AppendAction: envoycore.HeaderValueOption_OVERWRITE_IF_EXISTS_OR_ADD,
			},
			{
				Header: &envoycore.HeaderValue{
					Key:   "x-req-add",
					Value: "v2",
				},

							Cluster: clusterName,
						},
						Timeout: &durationpb.Duration{Seconds: 3},
					},
					RequestHeadersToAdd: []*core.HeaderValueOption{
						{
							Header: &core.HeaderValue{
								Key:   "custom-header",
								Value: "custom-value",
							},
							AppendAction: core.HeaderValueOption_OVERWRITE_IF_EXISTS_OR_ADD,
						},
					},
				},

        while (StringUtil.isNotBlank(headerName)) {
            final String headerValue = paramMap.get(CRAWLER_WEB_HEADER_PREFIX + count + ".value");
            rhList.add(new org.codelibs.fess.crawler.client.http.RequestHeader(headerName, headerValue));
            count++;
            headerName = paramMap.get(CRAWLER_WEB_HEADER_PREFIX + count + ".name");
        }

		//nolint: staticcheck
		allowedHeaders = generateHeaders(config.IncludeHeadersInCheck)
	}
	var headersToAdd []*core.HeaderValue
	additionalHeaders := maps.Keys(config.IncludeAdditionalHeadersInCheck)
	sort.Strings(additionalHeaders)
	for _, k := range additionalHeaders {
		headersToAdd = append(headersToAdd, &core.HeaderValue{
			Key:   k,
			Value: config.IncludeAdditionalHeadersInCheck[k],
		})
	}
	if len(headersToAdd) != 0 {

			TargetSpecifier: &core.GrpcService_EnvoyGrpc_{
				EnvoyGrpc: &core.GrpcService_EnvoyGrpc{
					ClusterName: clusterName,
					Authority:   hostname,
				},
			},
			InitialMetadata: []*core.HeaderValue{
				{
					Key:   "lightstep-access-token",
					Value: accessToken,
				},
			},
		},
	}
	return anypb.New(dc)
}

func configureDynatraceSampler(hostname, cluster string,

   * if this header is set.
   */
  @get:JvmName("onlyIfCached") val onlyIfCached: Boolean,
  @get:JvmName("noTransform") val noTransform: Boolean,
  @get:JvmName("immutable") val immutable: Boolean,
  internal var headerValue: String?,
) {
  @JvmName("-deprecated_noCache")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "noCache"),
    level = DeprecationLevel.ERROR,
  )

	}
	headerVal := strings.Join(valParts, ", ")
	return &core.HeaderValueOption{
		AppendAction: core.HeaderValueOption_APPEND_IF_EXISTS_OR_ADD,
		Header: &core.HeaderValue{
			Key:   util.AltSvcHeader,
			Value: headerVal,
		},
	}
}

// SortHeaderValueOption type and the functions below (Len, Less and Swap) are for sort.Stable for type HeaderValueOption

    responseCode: Int,
    headerName: String,
    headerValue: String,
  ) {
    server.enqueue(
      MockResponse.Builder()
        .code(responseCode)
        .addHeader(headerName, headerValue)
        .addHeader("Location", "/a")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .addHeader(headerName, headerValue)
        .body("a")
        .build(),
    )