*
   * <p>For example:
   *
   * {@snippet :
   * Streams.zip(
   *   Stream.of("foo1", "foo2", "foo3"),
   *   Stream.of("bar1", "bar2"),
   *   (arg1, arg2) -> arg1 + ":" + arg2)
   * }
   *
   * <p>will return {@code Stream.of("foo1:bar1", "foo2:bar2")}.
   *
   * <p>The resulting stream will only be as long as the shorter of the two input streams; if one

    ).isFalse()
  }

  @Test fun defaultPath() {
    assertThat(parse("http://example.com/foo/bar".toHttpUrl(), "a=b")!!.path).isEqualTo("/foo")
    assertThat(parse("http://example.com/foo/".toHttpUrl(), "a=b")!!.path).isEqualTo("/foo")
    assertThat(parse("http://example.com/foo".toHttpUrl(), "a=b")!!.path).isEqualTo("/")
    assertThat(parse("http://example.com/".toHttpUrl(), "a=b")!!.path).isEqualTo("/")
  }

    assertEquals("test >> 1", htmlEscaper().escape("test >> 1"));
    assertEquals("&lt;tab&gt;", htmlEscaper().escape("<tab>"));

    // Test simple escape of '&'.
    assertEquals("foo&amp;bar", htmlEscaper().escape("foo&bar"));

    // If the string contains no escapes, it should return the arg.
    // Note: assert<b>Same</b> for this implementation.
    String s = "blah blah farhvergnugen";

  }

  public void testContains() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertTrue(table.contains("foo", 1));
    assertTrue(table.contains("bar", 1));
    assertTrue(table.contains("foo", 3));
    assertFalse(table.contains("foo", 2));
    assertFalse(table.contains("bar", 3));
    assertFalse(table.contains("cat", 1));
    assertFalse(table.contains("foo", null));
    assertFalse(table.contains(null, 1));

  }

  public void testContains() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertTrue(table.contains("foo", 1));
    assertTrue(table.contains("bar", 1));
    assertTrue(table.contains("foo", 3));
    assertFalse(table.contains("foo", 2));
    assertFalse(table.contains("bar", 3));
    assertFalse(table.contains("cat", 1));
    assertFalse(table.contains("foo", null));
    assertFalse(table.contains(null, 1));

      assertEquals((Character) 'c', table.get("foo", 3));
    }
  }

  public void testRowClearAndPut() {
    if (supportsRemove()) {
      table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
      Map<Integer, C> row = table.row("foo");
      assertEquals(ImmutableMap.of(1, 'a', 3, 'c'), row);
      table.remove("foo", 3);

    multimap.put("foo", 3);
    multimap.put("foo", -1);
    multimap.put(null, null);
    multimap.put("bar", 1);
    multimap.put("foo", 2);
    multimap.put(null, 0);
    multimap.put("bar", 2);
    multimap.put("bar", null);
    multimap.put("foo", null);
    multimap.put("foo", 4);
    multimap.put(null, -1);
    multimap.put("bar", 3);

    assertEquals(
        ImmutableListMultimap.of('f', "foo", 'o', "foo", 'o', "foo"),
        ImmutableListMultimap.of("foo", 'f', "foo", 'o', "foo", 'o').inverse());
  }

  public void testNotDistinctEntrySpliterator() {
    ImmutableListMultimap<String, String> multimap =
        ImmutableListMultimap.of("foo", "bar", "foo", "bar");

    TestMap map = new TestMap();
    map.put("foo", 1);
    assertEquals(Integer.valueOf(1), map.putIfAbsent("foo", 2));
    assertEquals(Integer.valueOf(1), map.get("foo"));
    assertThat(map.putIfAbsent("bar", 3)).isNull();
    assertEquals(Integer.valueOf(3), map.get("bar"));
  }

  public void testRemove() {
    TestMap map = new TestMap();
    map.put("foo", 1);
    assertFalse(map.remove("foo", 2));
    assertFalse(map.remove("bar", 1));

      @Nullable Integer nullValue) {
    multimap.clear();
    multimap.put("foo", 1);
    multimap.put("foo", 2);
    multimap.put("foo", 3);
    multimap.put("bar", 5);
    multimap.put("bar", -1);
    multimap.put(nullKey, nullValue);
    multimap.put("foo", nullValue);
    multimap.put(nullKey, 5);
    multimap.put("foo", 2);

    if (permitsDuplicates) {
      assertEquals(9, multimap.size());