checkArgument(xDelta != 0.0);
    checkArgument(yDelta != 0.0);
    assertThat(transformation.isHorizontal()).isFalse();
    assertThat(transformation.isVertical()).isFalse();
    assertThat(transformation.inverse().isHorizontal()).isFalse();
    assertThat(transformation.inverse().isVertical()).isFalse();
    assertThat(transformation.transform(x1)).isWithin(ALLOWED_ERROR).of(y1);

    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun nonRetryableSSLHandshakeException() {
    val exception =
      SSLHandshakeException("Certificate handshake exception").apply {
        initCause(CertificateException())
      }
    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun retryableSSLHandshakeException() {

        Object value = warmed.get(i - WARMUP_MIN).getValue();
        assertThat(cache.asMap().remove(key, -1)).isFalse();
        assertThat(cache.asMap().remove(key, value)).isTrue();
        assertThat(cache.asMap().remove(key, -1)).isFalse();
        assertThat(cache.asMap().containsKey(key)).isFalse();
      }
      checkEmpty(cache);
    }
  }


  public void testKeySet_populated() {

    assertThat(future.set(99)).isFalse();
    assertThat(future.setException(new IndexOutOfBoundsException())).isFalse();
    assertThat(future.setFuture(new AbstractFuture<Integer>() {})).isFalse();
    assertThat(future.setFuture(immediateFuture(99))).isFalse();
  }

  private static void assertCannotCancel(AbstractFuture<?> future) {
    assertThat(future.cancel(true)).isFalse();
    assertThat(future.cancel(false)).isFalse();

    assertThat(graph.hasEdgeConnecting(EndpointPair.ordered(N1, N2))).isFalse();
    assertThat(graph.hasEdgeConnecting(EndpointPair.ordered(N2, N1))).isFalse();
  }

  @Test
  public void hasEdgeConnecting_missingNode() {
    // both nodes missing
    assertThat(
            graph.hasEdgeConnecting(EndpointPair.unordered(NODE_NOT_IN_GRAPH, NODE_NOT_IN_GRAPH)))
        .isFalse();

    // one node present, the other missing

    assertThat(cookie.domain).isEqualTo("example.com")
    assertThat(cookie.path).isEqualTo("/")
    assertThat(cookie.secure).isFalse()
    assertThat(cookie.httpOnly).isFalse()
    assertThat(cookie.persistent).isFalse()
    assertThat(cookie.hostOnly).isFalse()
    assertThat(cookie.sameSite).isNull()
  }

  @Test fun newBuilder() {
    val cookie =
      parseCookie(0L, url, "c=d; Max-Age=1")!!

    Future<?> possiblyIgnoredError1 = serializer.submitAsync(thirdCallable, directExecutor());
    secondFuture.cancel(true);
    assertThat(secondCallable.called).isFalse();
    assertThat(thirdCallable.called).isFalse();
    firstFuture.set(null);
    assertThat(secondCallable.called).isFalse();
    assertThat(thirdCallable.called).isTrue();
  }

  public void testCancellationMultipleThreads() throws Exception {

    testInstances += this

    assertThat(serverA.started).isTrue()
    assertThat(serverB.started).isTrue()
    assertThat(serverC.started).isFalse()

    assertThat(serverD.started).isTrue()
    assertThat(serverE.started).isTrue()
    assertThat(serverF.started).isFalse()
  }

  private companion object {
    val testInstances = CopyOnWriteArrayList<StartStopTest>()

    private val dispatcherD = ClosableDispatcher()

    assertThat(containsKey(cache, 654)).isFalse();
    assertThat(containsKey(cache, 2456)).isFalse();
    assertThat(containsKey(cache, 2)).isFalse();

    cache.put(654, 2675);
    cache.put(2456, 56);
    cache.put(2, 15);
    cache.put(1, 3);

    cache.invalidateAll(ImmutableSet.of(1, 2));

    assertThat(containsKey(cache, 1)).isFalse();
    assertThat(containsKey(cache, 2)).isFalse();

    assertThat(graph.hasEdgeConnecting(EndpointPair.ordered(N1, N2))).isFalse();
    assertThat(graph.hasEdgeConnecting(EndpointPair.ordered(N2, N1))).isFalse();
  }

  @Test
  public void hasEdgeConnecting_missingNode() {
    // both nodes missing
    assertThat(
            graph.hasEdgeConnecting(EndpointPair.unordered(NODE_NOT_IN_GRAPH, NODE_NOT_IN_GRAPH)))
        .isFalse();

    // one node present, the other missing