ImmutableSortedSet.Builder<LegacyComparable> builder =
        ImmutableSortedSet.<LegacyComparable>naturalOrder();

    builder.addAll(LegacyComparable.VALUES_BACKWARD);
    builder.add(LegacyComparable.X);
    builder.add(LegacyComparable.Y, LegacyComparable.Z);

    ImmutableSortedSet<LegacyComparable> set = builder.build();
    assertTrue(elementsEqual(LegacyComparable.VALUES_FORWARD, set));

  @Test
  fun tagsAreImmutable() {
    val builder =
      Request
        .Builder()
        .url("https://square.com")
    val requestA = builder.tag(String::class, "a").build()
    val requestB = builder.tag(String::class, "b").build()
    val requestC = requestA.newBuilder().tag(String::class, "c").build()
    assertThat(requestA.tag(String::class)).isSameAs("a")

  MockWebServer server = new MockWebServer();

  // Schedule some responses.
  server.enqueue(new MockResponse.Builder()
      .body("hello, world!")
      .build());
  server.enqueue(new MockResponse.Builder()
      .body("sup, bra?")
      .build());
  server.enqueue(new MockResponse.Builder()
      .body("yo dog")
      .build());

  // Start the server.
  server.start();

      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", otherServer.url("/"))
        .build(),
    )
    otherServer.enqueue(
      MockResponse
        .Builder()
        .headersDelay(500, TimeUnit.MILLISECONDS)
        .build(),
    )
    val request = Request.Builder().url(server.url("/")).build()
    val call = client.newCall(request)

        .Builder()
        .serialNumber(2L)
        .certificateAuthority(1)
        .signedBy(root)
        .build()
    val certB =
      HeldCertificate
        .Builder()
        .serialNumber(3L)
        .certificateAuthority(0)
        .signedBy(certA)
        .build()
    val certC =
      HeldCertificate
        .Builder()
        .serialNumber(4L)
        .signedBy(certB)
        .build()

    }
  }

  private fun testEncodeAndDecode(
    codePoint: Int,
    codePointString: String,
    component: Component,
  ) {
    val builder = "http://host/".toHttpUrl().newBuilder()
    component[builder] = codePointString
    val url = builder.build()
    val expected = component.canonicalize(codePointString)
    val actual = component[url]
    if (expected != actual) {

	builder.WriteQuoted(lt.Column)
	builder.WriteString(" < ")
	builder.AddVar(builder, lt.Value)
}

func (lt Lt) NegationBuild(builder Builder) {
	Gte(lt).Build(builder)
}

// Lte less than or equal to for where
type Lte Eq

func (lte Lte) Build(builder Builder) {
	builder.WriteQuoted(lte.Column)
	builder.WriteString(" <= ")
	builder.AddVar(builder, lte.Value)
}

    server.enqueue(
      MockResponse
        .Builder()
        .headersDelay(2, TimeUnit.SECONDS)
        .build(),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    assertFailsWith<IOException> {

        .certificatePinner(CertificatePinner.Builder().build())
        .build()
        .routeDatabase,
    )
  }

  @Test fun minWebSocketMessageToCompressNegative() {
    val builder = OkHttpClient.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.minWebSocketMessageToCompress(-1024)
    }.also { expected ->
      assertThat(expected.message)

        ArtifactResolverRequest.ArtifactResolverRequestBuilder builder = ArtifactResolverRequest.builder();

        ArtifactResolverRequest request1 = builder.session(session)
                .coordinates(Arrays.asList(coords1, coords2))
                .repositories(repositories1)
                .build();

        ArtifactResolverRequest request2 = builder.session(session)
                .coordinates(Arrays.asList(coords1, coords2))