() ->
                getChecked(
                    FAILED_FUTURE_CHECKED_EXCEPTION, ExceptionWithGoodAndBadConstructor.class));
    assertThat(expected).hasCauseThat().isSameInstanceAs(CHECKED_EXCEPTION);
  }

  // Boring timed-get tests:

  public void testGetCheckedTimed_success() throws TwoArgConstructorException {
    assertEquals(

    awaitBlockedOnInstanceOf(runner, InterruptibleTask.Blocker.class);

    Blocker blocker = (Blocker) LockSupport.getBlocker(runner);
    Thread owner = blocker.getOwner();
    assertThat(owner).isSameInstanceAs(interrupter);

    slowChannel.exitClose.countDown(); // release the interrupter

    // We need to wait for the runner to exit.  To make sure that the interrupting thread wakes it
    // back up.

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
    ExecutionException ee = assertThrows(ExecutionException.class, () -> future.get());
    assertThat(ee).hasCauseThat().isSameInstanceAs(e);
  }

  public void testSetFuture() throws Exception {
    SettableFuture<String> future = SettableFuture.create();
    SettableFuture<String> nested = SettableFuture.create();

    Network<String, String> network1 =
        ImmutableNetwork.copyOf(NetworkBuilder.directed().<String, String>build());
    Network<String, String> network2 = ImmutableNetwork.copyOf(network1);

    assertThat(network2).isSameInstanceAs(network1);
  }

  @Test
  public void edgesConnecting_directed() {
    MutableNetwork<String, String> mutableNetwork =
        NetworkBuilder.directed().allowsSelfLoops(true).build();

        ImmutableValueGraph.copyOf(ValueGraphBuilder.directed().<String, Integer>build());
    ValueGraph<String, Integer> graph2 = ImmutableValueGraph.copyOf(graph1);

    assertThat(graph2).isSameInstanceAs(graph1);
  }

  @Test
  public void incidentEdgeOrder_stable() {
    ImmutableValueGraph<String, Integer> immutableValueGraph =

    assertGoodFeatureEnum(ExampleFeature.class);
  }

  public void testAddImpliedFeatures_returnsSameSetInstance() {
    Set<Feature<?>> features = newHashSet(FOO);
    assertThat(addImpliedFeatures(features)).isSameInstanceAs(features);
  }

  public void testAddImpliedFeatures_addsImpliedFeatures() {
    assertThat(addImpliedFeatures(newHashSet(FOO))).containsExactly(FOO);

    // Ensure we get a unique execution exception on each get
    assertNotSame(ee1, ee2);

    assertThat(ee1).hasCauseThat().isSameInstanceAs(failure);
    assertThat(ee2).hasCauseThat().isSameInstanceAs(failure);

    checkStackTrace(ee1);
    checkStackTrace(ee2);
  }

  public void testCancel_notDoneNoInterrupt() throws Exception {

    assertGoodFeatureEnum(ExampleFeature.class);
  }

  public void testAddImpliedFeatures_returnsSameSetInstance() {
    Set<Feature<?>> features = newHashSet(FOO);
    assertThat(addImpliedFeatures(features)).isSameInstanceAs(features);
  }

  public void testAddImpliedFeatures_addsImpliedFeatures() {
    assertThat(addImpliedFeatures(newHashSet(FOO))).containsExactly(FOO);

      throws Exception {
    try {
      future.get();
      fail("Expected ExecutionException");
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().isSameInstanceAs(expectedCause);
    }
  }

  /** invokeAny(null) throws NPE */
  public void testInvokeAnyImpl_nullTasks() throws Exception {
    ListeningExecutorService e = newDirectExecutorService();
    try {

      throws Exception {
    try {
      future.get();
      fail("Expected ExecutionException");
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().isSameInstanceAs(expectedCause);
    }
  }

  /** invokeAny(null) throws NPE */
  public void testInvokeAnyImpl_nullTasks() throws Exception {
    ListeningExecutorService e = newDirectExecutorService();
    try {