.build(exceptionLoader(e));

    UncheckedExecutionException uee =
        assertThrows(UncheckedExecutionException.class, () -> map.getUnchecked(new Object()));
    assertThat(uee).hasCauseThat().isSameInstanceAs(e);
    assertTrue(listener.isEmpty());
    checkEmpty(map);
  }

            .build(exceptionLoader(e));

    UncheckedExecutionException uee =
        assertThrows(UncheckedExecutionException.class, () -> map.getUnchecked(new Object()));
    assertThat(uee).hasCauseThat().isSameInstanceAs(e);
    assertTrue(listener.isEmpty());
    checkEmpty(map);
  }

    }

    try {
      HostSpecifier.from(spec);
      fail("Should have thrown ParseException: " + spec);
    } catch (ParseException expected) {
      assertThat(expected).hasCauseThat().isInstanceOf(IllegalArgumentException.class);
    }

    assertFalse(HostSpecifier.isValid(spec));
  }

    }

    try {
      HostSpecifier.from(spec);
      fail("Should have thrown ParseException: " + spec);
    } catch (ParseException expected) {
      assertThat(expected).hasCauseThat().isInstanceOf(IllegalArgumentException.class);
    }

    assertFalse(HostSpecifier.isValid(spec));
  }

    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    ExecutionException executionException =
        assertThrows(ExecutionException.class, () -> getDone(task));
    assertThat(executionException).hasCauseThat().isEqualTo(e);
  }

  @J2ktIncompatible
  @GwtIncompatible // blocking wait
  public void testCancel_interrupted() throws Exception {
    final AtomicBoolean interruptedExceptionThrown = new AtomicBoolean();

    assertEquals(false, tearDownTwo.ran);

    try {
      stack.runTearDown();
      fail("runTearDown should have thrown an exception");
    } catch (ClusterException expected) {
      assertThat(expected).hasCauseThat().hasMessageThat().isEqualTo("two");
    } catch (RuntimeException e) {
      throw new RuntimeException(
          "A ClusterException should have been thrown, rather than a " + e.getClass().getName(), e);
    }

    ValueAndCloser<?> valueAndCloser = finishToValueAndCloser(closingFuture);
    try {
      valueAndCloser.get();
      fail();
    } catch (ExecutionException expected) {
      assertThat(expected).hasCauseThat().isSameInstanceAs(exception);
    }
    valueAndCloser.closeAsync();
  }

  @Override
  void assertBecomesCanceled(ClosingFuture<?> closingFuture) throws ExecutionException {

    assertEquals(false, tearDownTwo.ran);

    try {
      stack.runTearDown();
      fail("runTearDown should have thrown an exception");
    } catch (ClusterException expected) {
      assertThat(expected).hasCauseThat().hasMessageThat().isEqualTo("two");
    } catch (RuntimeException e) {
      throw new RuntimeException(
          "A ClusterException should have been thrown, rather than a " + e.getClass().getName(), e);
    }

    InvocationTargetException expected =
        assertThrows(
            InvocationTargetException.class,
            () -> subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT));
    assertThat(expected).hasCauseThat().isInstanceOf(IntentionalException.class);
  }

  public void testInvokeSubscriberMethod_errorPassthrough() throws Throwable {
    Method method = getTestSubscriberMethod("errorThrowingMethod");

    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();