val server =
    MockWebServer().apply {
      useHttps(handshakeCertificates.sslSocketFactory(), false)

      enqueue(
        MockResponse()
          .setResponseCode(HTTP_MOVED_TEMP)
          .setHeader("Location", "https://www.google.com/robots.txt"),
      )
    }

  val clientCertificates =
    HandshakeCertificates.Builder()
      .addPlatformTrustedCertificates()
      .addInsecureHost(server.hostName)

            "0000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010001000" +
            "0003b00049df00112",
        )
          .newBuilder()
          .setHeader("cache-control", "private, max-age=298")
          .build(),
      )
    }

    var result = cachedDns.lookup("google.com")
    assertThat(result).containsExactly(address("157.240.1.18"))

            new Random().nextBytes(connectionAuth.challenge)
            connections[HttpConnection.currentConnection] = connectionAuth
        }

        if (connectionAuth.failed) {
            httpResponse.setHeader(HttpHeader.WWW_AUTHENTICATE.asString(), "basic realm=\"" + _loginService.getName() + '"')
            httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED)
            return Authentication.SEND_CONTINUE

			g.Expect(len(routes)).To(Equal(1))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetName()).To(Equal("FOO-HEADER"))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetPresentMatch()).To(Equal(true))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetInvertMatch()).To(Equal(false))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetTreatMissingHeaderAsEmpty()).To(Equal(false))
		}
	})

        given:
        httpBuildCacheServer.cacheDir.createDir("redirect")
        httpBuildCacheServer.addResponder { req, res ->
            if (!req.requestURI.startsWith("/redirect")) {
                res.setHeader("location", "redirect$req.requestURI")
                res.setStatus(307)
                res.writer.close()
                false
            } else {
                true
            }
        }

                if (StringUtil.isBlank(responseContentType)) {
                    response.setHeader("Content-Type", "application/json");
                } else {
                    response.setHeader("Content-Type", responseContentType);
                }
                CopyUtil.copy(in, out);
            } catch (final ClientAbortException e) {

	attrs := request.GetAttributes()

	// Determine whether to allow or deny the request.
	allow := false
	checkHeaderValue, contains := attrs.GetRequest().GetHttp().GetHeaders()[checkHeader]
	if contains {
		allow = checkHeaderValue == allowedValue
	} else {
		allow = attrs.Source != nil && strings.HasSuffix(attrs.Source.Principal, "/sa/"+*serviceAccount)
	}

	if allow {

                    def auth = super.validateRequest(req, new ServletResponseHttpWrapper(res), mandatory)
                    if (!(auth instanceof Authentication.User)) {
                        res.setHeader(HttpHeader.WWW_AUTHENTICATE.asString(), "basic realm=\"" + _loginService.getName() + '"')
                        res.sendError(HttpServletResponse.SC_NOT_FOUND)
                        return Authentication.SEND_CONTINUE

        .clearHeaders()
        .addHeader("Cookie: s=square")
        .addHeader("Cookies: delicious")
    response.setHeaders(Headers.Builder().add("Cookie", "a=android").build())
    assertThat(headersToList(response)).containsExactly("Cookie: a=android")
  }

  @Test
  fun regularResponse() {
    server.enqueue(MockResponse().setBody("hello world"))
    val url = server.url("/").toUrl()

    mockResponse = mockResponse.addHeader("")
    mockResponse = mockResponse.addHeader("", "")
    mockResponse = mockResponse.addHeaderLenient("", Any())
    mockResponse = mockResponse.setHeader("", Any())
    mockResponse.headers = headersOf()
    mockResponse.trailers = headersOf()
    mockResponse = mockResponse.removeHeader("")
    var body: Buffer? = mockResponse.getBody()