Network<String, String> network = ImmutableNetwork.copyOf(mutableNetwork);

    assertThat(network.edgesConnecting("A", "A")).containsExactly("AA");
    assertThat(network.edgesConnecting("A", "B")).containsExactly("AB");
    assertThat(network.edgesConnecting("B", "A")).containsExactly("AB");
  }

  @Test
  public void immutableNetworkBuilder_appliesNetworkBuilderConfig() {
    ImmutableNetwork<String, Integer> emptyNetwork =

            .<String, Integer>immutable()
            .putEdgeValue("A", "B", 10)
            .build();

    assertThat(graph.nodes()).containsExactly("A", "B");
    assertThat(graph.edges()).containsExactly(EndpointPair.ordered("A", "B"));
    assertThat(graph.edgeValueOrDefault("A", "B", null)).isEqualTo(10);
  }

  @Test
  public void immutableValueGraphBuilder_putEdgeFromEndpointPair() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import java.util.ArrayDeque
import java.util.Deque

class RecordingCookieJar : CookieJar {
  private val requestCookies: Deque<List<Cookie>> = ArrayDeque()

        ),
      ),
    ).containsExactly(
      Mapping(0x0000, 0x002e, TYPE_VALID, ByteString.EMPTY),
    )
  }

  @Test fun withSectionStartsSplits() {
    assertThat(
      withoutSectionSpans(
        listOf(
          Mapping(0x40000, 0x40180, TYPE_DISALLOWED, ByteString.EMPTY),
        ),
      ),
    ).containsExactly(
      Mapping(0x40000, 0x4007f, TYPE_DISALLOWED, ByteString.EMPTY),

    ImmutableListMultimap<String, Integer> multimap = builder.build();
    assertThat(multimap.keySet()).containsExactly("d", "c", "b", "a").inOrder();
    assertThat(multimap.values()).containsExactly(2, 4, 3, 6, 5, 2).inOrder();
    assertThat(multimap.get("a")).containsExactly(5, 2).inOrder();
    assertThat(multimap.get("b")).containsExactly(3, 6).inOrder();
  }

  public void testBuilderOrderKeysByDuplicates() {

    assertThat(map.entrySet())
        .containsExactly(immutableEntry("foo", 1), immutableEntry("quux", 3))
        .inOrder();
  }

  public void testInsertionOrderAfterRemoveLast() {
    BiMap<String, Integer> map = HashBiMap.create();
    map.put("foo", 1);
    map.put("bar", 2);
    map.put("quux", 3);

    map.remove("quux");
    assertThat(map.entrySet())

  }

  public void testFindClassesToTest_noCorrespondingTestClass() {
    assertThat(findClassesToTest(ImmutableList.of(Foo.class))).containsExactly(Foo.class);
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, Foo2Test.class)))
        .containsExactly(Foo.class);
  }

  public void testFindClassesToTest_publicApiOnly() {
    sanityTests.publicApiOnly();

                + " version we released in a separate artifact com.google.guava:listenablefuture.")
        .that(ListenableFuture.class.getDeclaredMethods())
        .asList()
        .containsExactly(
            ListenableFuture.class.getMethod("addListener", Runnable.class, Executor.class));
    assertWithMessage(
            "Do not add new supertypes to ListenableFuture. Its API needs to continue to match the"

  public void testOf_headSet() {
    SortedSet<String> set = of("e", "f", "b", "d", "c");
    assertTrue(set.headSet("e") instanceof ImmutableSortedSet);
    assertThat(set.headSet("e")).containsExactly("b", "c", "d").inOrder();
    assertThat(set.headSet("g")).containsExactly("b", "c", "d", "e", "f").inOrder();
    assertSame(this.<String>of(), set.headSet("a"));
    assertSame(this.<String>of(), set.headSet("b"));
  }

        .add("kit:kat") // Space after colon is not required.
        .build()
    assertThat(headers.values("foo")).containsExactly("bar", "baz", "bak")
    assertThat(headers.values("key")).containsExactly("value")
    assertThat(headers.values("ping")).containsExactly("pong")
    assertThat(headers.values("kit")).containsExactly("kat")
  }

  @Test fun addThrowsOnEmptyName() {
    assertFailsWith<IllegalArgumentException> {