ImmutableValueGraph<String, Integer> immutableValueGraph =
        ImmutableValueGraph.copyOf(mutableValueGraph);

    assertThat(immutableValueGraph).isNotInstanceOf(MutableValueGraph.class);
    assertThat(immutableValueGraph).isEqualTo(mutableValueGraph);

    mutableValueGraph.addNode("B");
    assertThat(immutableValueGraph).isNotEqualTo(mutableValueGraph);
  }

  @Test
  public void copyOfImmutableValueGraph_optimized() {

    assertThat(Protocol.HTTP_1_0.toString()).isEqualTo("http/1.0")
    assertThat(Protocol.HTTP_1_1.toString()).isEqualTo("http/1.1")
    assertThat(Protocol.SPDY_3.toString()).isEqualTo("spdy/3.1")
    assertThat(Protocol.HTTP_2.toString()).isEqualTo("h2")
    assertThat(Protocol.H2_PRIOR_KNOWLEDGE.toString())
      .isEqualTo("h2_prior_knowledge")
    assertThat(Protocol.QUIC.toString()).isEqualTo("quic")

    assertThat(set.floor("f")).isNull();
  }

  public void testFloor_elementPresent() {
    ImmutableSortedSet<String> set =
        ImmutableSortedSet.copyOf(new String[] {"e", "a", "e", "f", "b", "i", "d", "a", "c", "k"});
    assertThat(set.floor("f")).isEqualTo("f");
    assertThat(set.floor("j")).isEqualTo("i");
    assertThat(set.floor("q")).isEqualTo("k");
  }

    Network<Integer, String> transpose = transpose(directedGraph);
    assertThat(transpose).isEqualTo(expectedTranspose);
    assertThat(transpose(transpose)).isSameInstanceAs(directedGraph);
    AbstractNetworkTest.validateNetwork(transpose);

    assertThat(transpose.edgesConnecting(N1, N2)).isEmpty();
    assertThat(transpose.edgeConnecting(N1, N2)).isEmpty();
    assertThat(transpose.edgeConnectingOrNull(N1, N2)).isNull();

                }
                System.out.println(path);
                assertThat(path, is(notNullValue()));
                assertThat(path, path.startsWith("junit") || path.startsWith("org/junit") || path.startsWith("org/hamcrest")
                        || path.startsWith("META-INF/") || path.equals("LICENSE-junit.txt"), is(true));
                assertThat(is, is(notNullValue()));
                count++;
            } finally {

        ) {
          assertThat(streamDependency).isEqualTo(0)
          assertThat(weight).isEqualTo(256)
          assertThat(exclusive).isFalse()
        }

        override fun headers(
          inFinished: Boolean,
          streamId: Int,
          associatedStreamId: Int,
          headerBlock: List<Header>,
        ) {
          assertThat(inFinished).isFalse()

    assertThat(loadCount.get()).isEqualTo(2);
    assertThat(reloadCount.get()).isEqualTo(1);
    assertThat(loadAllCount.get()).isEqualTo(2);

    executor.runNext();
    assertThat(loadCount.get()).isEqualTo(2);
    assertThat(reloadCount.get()).isEqualTo(2);
    assertThat(loadAllCount.get()).isEqualTo(2);
  }

            return "theDelegate";
          }
        };
    Executor sequential1 = newSequentialExecutor(delegate);
    Executor sequential2 = newSequentialExecutor(delegate);
    assertThat(sequential1.toString()).contains("theDelegate");
    assertThat(sequential1.toString()).isNotEqualTo(sequential2.toString());
    String[] whileRunningToString = new String[1];
    sequential1.execute(
        new Runnable() {
          @Override

    assertFalse(testTable.containsValue(""));
  }

  public void testGet() {
    assertEquals("blah", testTable.get('a', 1));
    assertThat(testTable.get('a', 2)).isNull();
    assertThat(testTable.get('A', 1)).isNull();
    assertThat(testTable.get('A', 2)).isNull();
  }

  public void testIsEmpty() {
    assertFalse(testTable.isEmpty());
  }

  public void testSize() {

        lru.put("bbb", "222");
        lru.put("ccc", "333");
        assertThat(lru.get("aaa"), is("111"));
        Iterator<String> i = lru.keySet().iterator();
        assertThat(i.next(), is("bbb"));
        assertThat(i.next(), is("ccc"));
        assertThat(i.next(), is("aaa"));
        lru.put("ddd", "444");
        assertThat(lru.size(), is(3));
        assertThat(lru.get("bbb"), is(nullValue()));
        i = lru.keySet().iterator();