.toByteString()
                    .hex(),
                )
              }
            },
          ),
        ).build()

    val request = Request.Builder().url("https://facebook.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)

}

func newExitCodeFilter(w io.Writer) (*exitCodeFilter, string) {
	const exitStr = "exitcode="

	// Build a regexp that matches any prefix of the exit string at the end of
	// the input. We do it this way to avoid assuming anything about the
	// subcommand output (e.g., it might not be \n-terminated).
	var exitReStr strings.Builder
	for i := 1; i <= len(exitStr); i++ {
		fmt.Fprintf(&exitReStr, "%s$|", exitStr[:i])
	}

    protected Invoker createInvoker() {
        return new EncryptInvoker(
                ProtoLookup.builder().addMapping(ClassWorld.class, classWorld).build(), null);
    }

    @Override
    protected Parser createParser() {
        return new EncryptParser();
    }

    @Override
    protected ParserRequest.Builder createParserRequestBuilder(String[] args) {
        return ParserRequest.mvnenc(args, createMessageBuilderFactory());

    protected Invoker createInvoker() {
        return new ShellInvoker(
                ProtoLookup.builder().addMapping(ClassWorld.class, classWorld).build(), null);
    }

    @Override
    protected Parser createParser() {
        return new ShellParser();
    }

    @Override
    protected ParserRequest.Builder createParserRequestBuilder(String[] args) {
        return ParserRequest.mvnsh(args, createMessageBuilderFactory());

  fun run() {
    val request =
      Request
        .Builder()
        .url("https://api.github.com/repos/square/okhttp/issues")
        .header("User-Agent", "OkHttp Headers.java")
        .addHeader("Accept", "application/json; q=0.5")
        .addHeader("Accept", "application/vnd.github.v3+json")
        .build()

    client.newCall(request).execute().use { response ->

        return (version != null ? version : "<version unknown>");
    }

    /**
     * Create a human-readable string containing the Maven version, buildnumber, and time of build
     *
     * @param buildProperties The build properties
     * @return Readable build info
     */
    public static String createMavenVersionString(Properties buildProperties) {
        String version = reduce(buildProperties.getProperty(BUILD_VERSION_PROPERTY));

            } finally {
              firstConnectLatch.countDown()
            }
          },
        ).build()

    // Set up a same-connection retry.
    serverIpv4.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
        .build(),
    )
    serverIpv4.enqueue(
      MockResponse(body = "this was the 2nd request on IPv4"),
    )

        new ImmutableMultimap.Builder<Integer, String>().put(1, "one").put(2, "two").build();

    // copy into existing multimap
    assertThat(Multimaps.invertFrom(single, multimap)).isSameInstanceAs(multimap);

    ImmutableMultimap<String, Integer> expected =
        new ImmutableMultimap.Builder<String, Integer>().put("one", 1).put("two", 2).build();

    assertEquals(expected, multimap);
  }

    ImmutableList.Builder<List<E>> axesBuilder = new ImmutableList.Builder<>(lists.size());
    for (List<? extends E> list : lists) {
      List<E> copy = ImmutableList.copyOf(list);
      if (copy.isEmpty()) {
        return ImmutableList.of();
      }
      axesBuilder.add(copy);
    }
    return new CartesianList<>(axesBuilder.build());
  }

  CartesianList(ImmutableList<List<E>> axes) {

    if (!isSpecialHeader(parts[0])) {
      request.header(parts[0], parts[1])
    }
  }
  referer?.let {
    request.header("Referer", it)
  }
  request.header("User-Agent", userAgent)

  return request.build()
}

private fun Main.mediaType(): MediaType? {
  val mimeType =
    headers?.let {
      for (header in it) {
        val parts = header.split(':', limit = 2)