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(map.segments[0].table.length()).isEqualTo(16 / map.segments.length);

    assertThat(map.evictsBySize()).isFalse();
    assertThat(map.expires()).isFalse();
    assertThat(map.expiresAfterWrite()).isFalse();
    assertThat(map.expiresAfterAccess()).isFalse();
    assertThat(map.refreshes()).isFalse();
  }

  public void testSetKeyEquivalence() {
    Equivalence<Object> testEquivalence =

    assertThat(hasCycle(directedGraph)).isFalse();
    assertThat(hasCycle(undirectedGraph)).isFalse();
  }

  @Test
  public void hasCycle_isolatedNodes() {
    for (MutableGraph<Integer> graph : graphsToTest) {
      graph.addNode(1);
      graph.addNode(2);
    }
    assertThat(hasCycle(directedGraph)).isFalse();
    assertThat(hasCycle(undirectedGraph)).isFalse();
  }

  @Test

    assertThat(map.segments[0].table.length()).isEqualTo(16 / map.segments.length);

    assertThat(map.evictsBySize()).isFalse();
    assertThat(map.expires()).isFalse();
    assertThat(map.expiresAfterWrite()).isFalse();
    assertThat(map.expiresAfterAccess()).isFalse();
    assertThat(map.refreshes()).isFalse();
  }

  public void testSetKeyEquivalence() {
    Equivalence<Object> testEquivalence =

    assertThat(selection2.hasNext()).isFalse()

    // The second selection will contain all failed routes.
    val selection3 = routeSelector.next()
    assertThat(selection3.next()).isEqualTo(regularRoutes[0])
    assertThat(selection3.hasNext()).isFalse()
    assertThat(routeSelector.hasNext()).isFalse()
  }

  @Test fun failedRouteWithMultipleProxies() {

    CompactHashSet<Integer> set = CompactHashSet.create();
    assertThat(set.needsAllocArrays()).isTrue();
    assertThat(set.elements).isNull();

    set.add(1);
    assertThat(set.needsAllocArrays()).isFalse();
    assertThat(set.elements).hasLength(CompactHashing.DEFAULT_SIZE);
  }

  public void testAllocArraysExpectedSize() {
    for (int i = 0; i <= CompactHashing.DEFAULT_SIZE; i++) {

      assertThat(cache.asMap().isEmpty()).isFalse();
      cache.invalidateAll();
      assertThat(cache.size()).isEqualTo(0);
      assertThat(cache.asMap().isEmpty()).isTrue();
      assertThat(cache.asMap().containsKey(key)).isFalse();
      assertThat(cache.asMap().containsValue(value)).isFalse();
    }
  }

  public void testKeySetEntrySetValues() {

    assertThat(ImmutableIntArray.of().isEmpty()).isTrue();
    assertThat(ImmutableIntArray.of(0).isEmpty()).isFalse();
    assertThat(ImmutableIntArray.of(0, 1, 3).isEmpty()).isFalse();
    assertThat(ImmutableIntArray.of(0, 1, 3).subArray(1, 1).isEmpty()).isTrue();
    assertThat(ImmutableIntArray.of(0, 1, 3).subArray(1, 2).isEmpty()).isFalse();
  }

  public void testGet_good() {
    ImmutableIntArray iia = ImmutableIntArray.of(0, 1, 3);

    assertThat(map.containsKey(one)).isTrue();
    assertThat(map.containsValue(one)).isFalse();
    Object three = new Object();
    assertThat(map.replace(one, two, three)).isTrue();
    assertThat(map.remove(one, three)).isTrue();
    assertThat(map.containsKey(one)).isFalse();
    assertThat(map.containsValue(one)).isFalse();
    assertThat(map.putIfAbsent(two, three)).isNull();

    assertThat(map.containsKey(one)).isTrue();
    assertThat(map.containsValue(one)).isFalse();
    Object three = new Object();
    assertThat(map.replace(one, two, three)).isTrue();
    assertThat(map.remove(one, three)).isTrue();
    assertThat(map.containsKey(one)).isFalse();
    assertThat(map.containsValue(one)).isFalse();
    assertThat(map.putIfAbsent(two, three)).isNull();