.isEqualTo("application/json; charset=utf-8")
    assertThat(bodyAsString(body)).isEqualTo("foo")
  }

  @Test
  fun referer() {
    val request = fromArgs("-e", "foo", "http://example.com").createRequest()
    assertThat(request.method).isEqualTo("GET")
    assertThat(request.url.toString()).isEqualTo("http://example.com/")
    assertThat(request.header("Referer")).isEqualTo("foo")
    assertThat(request.body).isNull()

    assertThat(cacheControl.maxAgeSeconds).isEqualTo(1)
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(2)
    assertThat(cacheControl.isPrivate).isTrue()
    assertThat(cacheControl.isPublic).isTrue()
    assertThat(cacheControl.mustRevalidate).isTrue()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(3)
    assertThat(cacheControl.minFreshSeconds).isEqualTo(4)
    assertThat(cacheControl.onlyIfCached).isTrue()

    assertThat(pool.closeConnections(50L)).isEqualTo(100L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 60, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(60L)).isEqualTo(90L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    assertTrue(queue.add("hi"));
    assertThat(queue.element()).isEqualTo("hi");
    assertThat(queue.peek()).isEqualTo("hi");
    assertEquals(1, queue.size());
    assertEquals(0, queue.remainingCapacity());

    assertTrue(queue.add("there"));
    assertThat(queue.element()).isEqualTo("there");
    assertThat(queue.peek()).isEqualTo("there");
    assertEquals(1, queue.size());

    assertThat(xmlEscaper.escape("xxx")).isEqualTo("xxx");
    assertThat(xmlEscaper.escape("test & test & test")).isEqualTo("test & test & test");
    assertThat(xmlEscaper.escape("test << 1")).isEqualTo("test &lt;&lt; 1");
    assertThat(xmlEscaper.escape("test >> 1")).isEqualTo("test &gt;&gt; 1");
    assertThat(xmlEscaper.escape("<tab>")).isEqualTo("&lt;tab&gt;");

    // Test all non-escaped ASCII characters.

          .that(UnsignedInteger.fromIntBits(value).intValue())
          .isEqualTo(value);
    }
  }

  public void testFromIntBitsLongValue() {
    for (int value : TEST_INTS) {
      long expected = value & 0xffffffffL;
      assertWithMessage(UnsignedInts.toString(value))
          .that(UnsignedInteger.fromIntBits(value).longValue())
          .isEqualTo(expected);
    }
  }

  public void testValueOfLong() {

    assertThat(certificatePinner.findMatchingPins(".example.com")).isEqualTo(expectedPin1)
    assertThat(certificatePinner.findMatchingPins("..example.com")).isEqualTo(expectedPin1)
    assertThat(certificatePinner.findMatchingPins("a..example.com")).isEqualTo(expectedPin1)
    assertThat(certificatePinner.findMatchingPins("a.b.example.com")).isEqualTo(expectedPin1)
  }

  @Test

    String result = executorService.invokeAny(tasks, Duration.ofSeconds(7));

    assertThat(result).isEqualTo("invokeAny");
    assertThat(recordedTasks).isSameInstanceAs(tasks);
    assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
    assertThat(Duration.ofNanos(recordedTimeout)).isEqualTo(Duration.ofSeconds(7));
  }

  public void testInvokeAll() throws Exception {

    Comparator<Optional<String>> unused = emptiesLast(naturalOrder());
  }

  public void testMinMaxNatural() {
    assertThat(min(1, 2)).isEqualTo(1);
    assertThat(min(2, 1)).isEqualTo(1);
    assertThat(max(1, 2)).isEqualTo(2);
    assertThat(max(2, 1)).isEqualTo(2);
  }

  public void testMinMaxNatural_equalInstances() {
    Foo a = new Foo(1);
    Foo b = new Foo(1);

    assertThat(Reflection.getPackageName(Iterable.class)).isEqualTo("java.lang");
    assertThat(Reflection.getPackageName("java.MyType")).isEqualTo("java");
    assertThat(Reflection.getPackageName(Iterable.class.getName())).isEqualTo("java.lang");
    assertThat(Reflection.getPackageName("NoPackage")).isEqualTo("");
    assertThat(Reflection.getPackageName(Map.Entry.class)).isEqualTo("java.util");
  }