*/
class CppLib extends CppSourceElement {
    final greeter = new CppGreeter().asLib()
    final sum = new CppSum().asLib()

    @Override
    SourceElement getHeaders() {
        ofElements(greeter.headers, sum.headers)
    }

    SourceElement getPublicHeaders() {
        ofElements(greeter.publicHeaders, sum.publicHeaders)
    }

    SourceElement getPrivateHeaders() {

     */
    fun webSocketUpgrade(listener: WebSocketListener) =
      apply {
        status = "HTTP/1.1 101 Switching Protocols"
        setHeader("Connection", "Upgrade")
        setHeader("Upgrade", "websocket")
        webSocketListener = listener
      }

    /**
     * Configures this response to be served as a response to an HTTP CONNECT request, either for

  @Test
  fun processResponse() {
    server.enqueue(
      MockResponse.Builder()
        .body(
          """
          |data: hey
          |
          |
          """.trimMargin(),
        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()

     */
    DomainObjectSet<NativeLibraryBinary> getBinaries();

    /**
     * The headers exported by this library. These headers will be added to all binaries for this library.
     */
    SourceDirectorySet getHeaders();

	for _, h := range headers {
		// Avoid using .Add() to allow users to pass non-canonical forms
		out[h.Key] = append(out[h.Key], h.Value)
	}
	return out
}

// GetHeaders returns the headers for the message.
func GetHeaders(request *proto.ForwardEchoRequest) http.Header {
	return ProtoToHTTPHeaders(request.Headers)
}

// MicrosToDuration converts the given microseconds to a time.Duration.

      .assertNoMoreLogs()
  }

  @Test
  fun bodyResponseGzipEncoded() {
    setLevel(Level.BODY)
    server.enqueue(
      MockResponse.Builder()
        .setHeader("Content-Encoding", "gzip")
        .setHeader("Content-Type", PLAIN)
        .body(Buffer().write("H4sIAAAAAAAAAPNIzcnJ11HwQKIAdyO+9hMAAAA=".decodeBase64()!!))
        .build(),
    )

		}
	}
}

func headerContains(hType echoClient.HeaderType, expected map[string][]string) echo.Checker {
	return check.Each(func(r echoClient.Response) error {
		h := r.GetHeaders(hType)
		for _, key := range sortKeys(expected) {
			actual := h.Get(key)

			for _, value := range expected[key] {
				if !strings.Contains(actual, value) {

  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"))

        return xml.ItemGroup.findAll({ it.'@Label' == 'Filters' })[0]
    }

    private Node getSources() {
        return xml.ItemGroup.find({ it.'@Label' == 'Sources' }) as Node
    }

    private Node getHeaders() {
        return xml.ItemGroup.find({ it.'@Label' == 'Headers' }) as Node
    }

    private String toPath(File it) {
        fileLocationResolver.transform(it)
    }