.testEquals();
  }

  public void testWrap_get() {
    String test = "test";
    Wrapper<String> wrapper = LENGTH_EQUIVALENCE.wrap(test);
    assertSame(test, wrapper.get());
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testSerialization() {
    SerializableTester.reserializeAndAssert(LENGTH_EQUIVALENCE.wrap("hello"));

    f.addCallback(
        new FutureCallback<String>() {
          @Override
          public void onSuccess(String result) {
            called[0] = true;
          }

          @Override
          public void onFailure(Throwable t) {}
        },
        directExecutor());
    assertThat(called[0]).isTrue();
  }

  // Avoid trouble with automatic mapping between JRE and Kotlin runtime classes.

  interface Interface1 {
    @Subscribe
    void annotatedIn1(Object o);

    @Subscribe
    void annotatedIn1And2(Object o);

    @Subscribe
    void annotatedIn1And2AndClass(Object o);

    void declaredIn1AnnotatedIn2(Object o);

    void declaredIn1AnnotatedInClass(Object o);

    void nowhereAnnotated(Object o);
  }

  interface Interface2 extends Interface1 {

  }

  public void testMappingAnd_infiniteY2() {
    assertThrows(
        IllegalArgumentException.class,
        () -> LinearTransformation.mapping(1.2, 3.4).and(5.6, Double.POSITIVE_INFINITY));
  }

  public void testMapping_nanX1() {
    assertThrows(
        IllegalArgumentException.class, () -> LinearTransformation.mapping(Double.NaN, 3.4));
  }

  public void testMapping_nanY1() {
    assertThrows(

  }

  public void testMappingAnd_infiniteY2() {
    assertThrows(
        IllegalArgumentException.class,
        () -> LinearTransformation.mapping(1.2, 3.4).and(5.6, Double.POSITIVE_INFINITY));
  }

  public void testMapping_nanX1() {
    assertThrows(
        IllegalArgumentException.class, () -> LinearTransformation.mapping(Double.NaN, 3.4));
  }

  public void testMapping_nanY1() {
    assertThrows(

  }

  public void testGet() {
    assertEquals("blah", testTable.get('a', 1));
    assertNull(testTable.get('a', 2));
    assertNull(testTable.get('A', 1));
    assertNull(testTable.get('A', 2));
  }

  public void testIsEmpty() {
    assertFalse(testTable.isEmpty());
  }

  public void testSize() {
    assertEquals(1, testTable.size());
  }

  public void testValues() {

  public void testLowerHyphenToUpperCamel() {
    assertEquals("Foo", LOWER_HYPHEN.to(UPPER_CAMEL, "foo"));
    assertEquals("FooBar", LOWER_HYPHEN.to(UPPER_CAMEL, "foo-bar"));
  }

  public void testLowerHyphenToUpperUnderscore() {
    assertEquals("FOO", LOWER_HYPHEN.to(UPPER_UNDERSCORE, "foo"));
    assertEquals("FOO_BAR", LOWER_HYPHEN.to(UPPER_UNDERSCORE, "foo-bar"));
  }

  public void testLowerUnderscoreToLowerHyphen() {

  @Override
  void write(int b);

  @Override
  void write(byte b[]);

  @Override
  void write(byte b[], int off, int len);

  @Override
  void writeBoolean(boolean v);

  @Override
  void writeByte(int v);

  @Override
  void writeShort(int v);

  @Override
  void writeChar(int v);

  @Override
  void writeInt(int v);

  @Override

  }

  public void testWildcardFuture() {
    SettableFuture<String> settable = SettableFuture.create();
    ListenableFuture<?> f = settable;
    FutureCallback<Object> callback =
        new FutureCallback<Object>() {
          @Override
          public void onSuccess(Object result) {}

          @Override
          public void onFailure(Throwable t) {}
        };

  }

  @J2ktIncompatible
  @GwtIncompatible // threads
  public void testRenaming() throws Exception {
    String oldName = Thread.currentThread().getName();
    final Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");
    Callable<@Nullable Void> callable =
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {