TypeToken<Object>.TypeSet types = new TypeToken<Object>() {}.getTypes();
    assertThat(types).contains(TypeToken.of(Object.class));
    assertThat(types.rawTypes()).contains(Object.class);
    assertThat(types.interfaces()).isEmpty();
    assertThat(types.interfaces().rawTypes()).isEmpty();
    assertThat(types.classes()).contains(TypeToken.of(Object.class));
    assertThat(types.classes().rawTypes()).contains(Object.class);
  }

            if (count < 10) {
                System.out.println(ClassUtil.concatName(packageName, shortClassName));
            }
            assertThat(packageName, is(notNullValue()));
            assertThat(shortClassName, is(notNullValue()));
            assertThat(packageName,
                    packageName.startsWith("junit") || packageName.startsWith("org.junit") || packageName.startsWith("org.hamcrest"),

    assertThat(set.floor("f")).isEqualTo("f");
    assertThat(set.floor("j")).isEqualTo("i");
    assertThat(set.floor("q")).isEqualTo("k");
  }

  public void testFloor_elementAbsent() {
    ImmutableSortedSet<String> set =
        ImmutableSortedSet.copyOf(new String[] {"e", "e", "f", "b", "i", "d", "c", "k"});
    assertThat(set.floor("a")).isNull();
  }

    for (long value : TEST_LONGS) {
      boolean expectSuccess = value >= min && value <= max;
      try {
        assertThat(UnsignedInteger.valueOf(value).longValue()).isEqualTo(value);
        assertThat(expectSuccess).isTrue();
      } catch (IllegalArgumentException e) {
        assertThat(expectSuccess).isFalse();
      }
    }
  }

  public void testValueOfBigInteger() {
    long min = 0;

  }

  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(min(a, b)).isSameInstanceAs(a);
    assertThat(max(a, b)).isSameInstanceAs(a);
  }

    executionThread.join();
    assertThat(expected).hasCauseThat().isEqualTo(service.failureCause());
    assertThat(expected).hasCauseThat().hasMessageThat().isEqualTo("kaboom!");
    assertTrue(service.shutDownCalled);
    assertEquals(Service.State.FAILED, service.state());
    assertThat(expected.getCause().getSuppressed()[0]).hasMessageThat().isEqualTo("double kaboom!");
  }

    assertThat(Buffer().writeUtf8("white\t space").isProbablyUtf8()).isTrue()
    assertThat(Buffer().writeByte(0x80).isProbablyUtf8()).isTrue()
    assertThat(Buffer().writeByte(0x00).isProbablyUtf8()).isFalse()
    assertThat(Buffer().writeByte(0xc0).isProbablyUtf8()).isFalse()
  }

package com.google.common.testing;

import static com.google.common.base.Preconditions.checkState;
import static com.google.common.testing.ReflectionFreeAssertThrows.assertThrows;
import static com.google.common.truth.Truth.assertThat;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Equivalence;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableMap;

package com.google.common.testing;

import static com.google.common.base.Preconditions.checkState;
import static com.google.common.testing.ReflectionFreeAssertThrows.assertThrows;
import static com.google.common.truth.Truth.assertThat;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Equivalence;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableMap;

    val response = httpClient.send(request, BodyHandlers.ofString())
    assertThat(response.statusCode()).isEqualTo(200)
    assertThat(response.body()).isEqualTo("hello, Java HTTP Client")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isNull() // No built-in gzip.
    assertThat(recorded.headers["Connection"]).isEqualTo("Upgrade, HTTP2-Settings")