final main = new CppMainWithOptionalFeature(greeter)

    @Override
    SourceElement getSources() {
        return ofElements(main, greeter.sources)
    }

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

    AppElement withFeatureDisabled() {
        return main
    }

    AppElement withFeatureEnabled() {
        return main.withFeatureEnabled()

	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.

		}
	}
}

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

    }

    public String getAccessTokenFromRequest(final HttpServletRequest request) {
        final String token = request.getHeader("Authorization");
        if (token != null) {
            final String[] values = token.trim().split(" ");
            if (values.length == 2 && BEARER.equals(values[0])) {
                return values[1];
            }

 */
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() {

        this.method = method;
        this.effectiveUri = effectiveUri;
        this.httpResponse = httpResponse;
    }

    public String getHeader(String name) {
        Header header = httpResponse.getFirstHeader(name);
        return header == null ? null : header.getValue();
    }

    public InputStream getContent() throws IOException {

                FEMALE, MALE, OTHER
            }

            @Managed
            interface Person {
              String getName()
              void setName(String string)

              Gender getGender()
              void setGender(Gender gender)
            }

            class Rules extends RuleSource {
              @Model
              void p1(Person p1) {}
            }

            apply type: Rules

        }

        final DeserializeMap map = classLoaderRegistry.newDeserializeSession();
        try {
            final Map<Short, ClassLoaderDetails> classLoaderDetails = Cast.uncheckedNonnullCast(payload.getHeader());
            StreamByteBuffer buffer = StreamByteBuffer.of(payload.getSerializedModel());

            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

  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)