ImmutableNetwork<String, Integer> immutableNetwork = ImmutableNetwork.copyOf(mutableNetwork);

    assertThat(immutableNetwork).isNotInstanceOf(MutableNetwork.class);
    assertThat(immutableNetwork).isEqualTo(mutableNetwork);

    mutableNetwork.addNode("B");
    assertThat(immutableNetwork).isNotEqualTo(mutableNetwork);
  }

  @Test
  public void copyOfImmutableNetwork_optimized() {

    assertEquals(42, queue.maximumSize);
    assertThat(queue.comparator()).isEqualTo(SOME_COMPARATOR);
  }

  // TODO: tests that check the weird interplay between expected size,
  // maximum size, size of initial contents, default capacity...

  private static void checkNatural(MinMaxPriorityQueue<Integer> queue) {
    assertThat(queue.comparator()).isEqualTo(Ordering.natural());
  }

    LongAdder longAdder = new LongAdder();
    longAdder.add(Long.MAX_VALUE);
    assertThat(longAdder.sum()).isEqualTo(Long.MAX_VALUE);
    longAdder.add(1);
    // silently overflows; is this a bug?
    // See https://github.com/google/guava/issues/3503
    assertThat(longAdder.sum()).isEqualTo(-9223372036854775808L);
  }

    assertThat(multiset.toString()).isEqualTo("[foo x 2, bar]");
  }

  public void testCreateWithSize() {
    Multiset<String> multiset = LinkedHashMultiset.create(50);
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
    assertThat(multiset.toString()).isEqualTo("[foo x 2, bar]");
  }

      cache.invalidate(key1);
      assertThat(cache.asMap().containsKey(key1)).isFalse();
      assertThat(cache.asMap().containsKey(key2)).isTrue();
      assertThat(cache.size()).isEqualTo(1);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key2));
      assertThat(cache.asMap().values()).contains(value2);
      assertThat(cache.asMap().entrySet()).containsExactly(immutableEntry(key2, value2));
    }
  }

  public void testUsingExpectedAtomicHelper() throws Exception {
    if (isJava8() || isAndroid()) {
      assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("UnsafeAtomicHelper");
    } else {
      assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("VarHandleAtomicHelper");
    }
  }

  private static boolean isJava8() {
    return JAVA_SPECIFICATION_VERSION.value().equals("1.8");
  }

    assertThat(entry.getKey()).isEqualTo("foo");
    assertThat(entry.getValue()).containsExactly(1, 3, 7);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("google");
    assertThat(entry.getValue()).containsExactly(2, 6);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("tree");
    assertThat(entry.getValue()).containsExactly(0, 4);
  }

  public void inDegree_oneEdge() {
    addEdge(N1, N2, E12);
    assertThat(network.inDegree(N2)).isEqualTo(1);
    assertThat(network.inDegree(N1)).isEqualTo(1);
  }

  @Test
  public void outDegree_oneEdge() {
    addEdge(N1, N2, E12);
    assertThat(network.outDegree(N1)).isEqualTo(1);
    assertThat(network.outDegree(N2)).isEqualTo(1);
  }

  @Test
  public void edges_selfLoop() {

      String expected = Ascii.toLowerCase(fieldName).replaceAll("_", ".");
      assertThat(property.key()).isEqualTo(expected);
    }
  }

  public void testGetValue() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {
      assertThat(property.value()).isEqualTo(System.getProperty(property.key()));
    }
  }

  public void testToString() {

        .Builder()
        .url("https://valid-isrgrootx1.letsencrypt.org/robots.txt")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(404)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)
    }
  }