}
  }

  /** toString returns current value */
  public void testToString() {
    AtomicDouble at = new AtomicDouble();
    assertThat(at.toString()).isEqualTo("0.0");
    for (double x : VALUES) {
      at.set(x);
      assertThat(at.toString()).isEqualTo(Double.toString(x));
    }
  }

  /** intValue returns current value. */
  public void testIntValue() {
    AtomicDouble at = new AtomicDouble();

      fail("runTearDown should have thrown an exception");
    } catch (RuntimeException expected) {
      assertThat(expected).hasMessageThat().isEqualTo("two");
      assertThat(getOnlyElement(asList(expected.getSuppressed())))
          .hasMessageThat()
          .isEqualTo("one");
    }

    assertEquals(true, tearDownOne.ran);
    assertEquals(true, tearDownTwo.ran);
  }

  @Override

    sink.writeLines(lines.stream(), separator);

    assertContainsExpectedLines(separator);
  }

  private void assertContainsExpectedString() throws IOException {
    assertThat(factory.getSinkContents()).isEqualTo(expected);
  }

  private void assertContainsExpectedLines(String separator) throws IOException {
    String expected = expectedLines.isEmpty() ? "" : Joiner.on(separator).join(expectedLines);

  }

  public void testVerify_simpleMessage_failure() {
    VerifyException expected = assertThrows(VerifyException.class, () -> verify(false, "message"));
    assertThat(expected).hasMessageThat().isEqualTo("message");
  }

  public void testVerify_complexMessage_success() {
    verify(true, "%s", IGNORE_ME);
  }

  public void testVerify_complexMessage_failure() {

    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    assertThat(entry.toString()).isEqualTo("(foo,1)=a");

    Cell<@Nullable String, @Nullable Integer, @Nullable Character> nullEntry =
        immutableCell(null, null, null);
    assertThat(nullEntry.toString()).isEqualTo("(null,null)=null");
  }

  public void testEntryEquals() {

  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testToStringFunction_apply() {
    assertThat(Functions.toStringFunction().apply(3)).isEqualTo("3");
    assertThat(Functions.toStringFunction().apply("hiya")).isEqualTo("hiya");
    assertThat(
            Functions.toStringFunction()
                .apply(
                    new Object() {
                      @Override

        transformValues(ImmutableMap.of("a", 1), Functions.toStringFunction());
    Map<String, String> expected = ImmutableMap.of("a", "1");
    assertMapsEqual(expected, map);
    assertThat(map.get("a")).isEqualTo(expected.get("a"));
  }

  public void testTransformIdentityFunctionEquality() {
    Map<String, Integer> underlying = ImmutableMap.of("a", 1);

  }

  public void testUnion_maxSize_saturated() {
    assertThat(union(setSize(Integer.MAX_VALUE), setSize(1)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
    assertThat(union(setSize(1), setSize(Integer.MAX_VALUE)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
  }

  public void testIntersection_minSize() {
    assertMinSize(intersection(emptySet(), emptySet()), 0);

    assertDone(future);
    assertThat(future.isCancelled()).isFalse();

    assertThat(getDone(future)).isEqualTo(expectedResult);
    assertThat(getDoneFromTimeoutOverload(future)).isEqualTo(expectedResult);

    assertThat(future.resultNow()).isEqualTo(expectedResult);
    assertThrows(IllegalStateException.class, future::exceptionNow);
  }

  private static void assertFailed(

    assertEquals(2, map.size());

    Number zero = map.getInstance(Number.class);
    assertEquals(0, zero);

    Double pi = map.getInstance(Double.class);
    assertThat(pi).isEqualTo(Math.PI);

    assertThat(ImmutableClassToInstanceMap.copyOf(map)).isSameInstanceAs(map);
  }

  public void testCopyOf_map_nulls() {