expectedTable.put('a', 1, "foo");
    expectedTable.put('b', 1, "bar");
    expectedTable.put('a', 2, "baz");
    Table<Character, Integer, String> otherTable = HashBasedTable.create();
    otherTable.put('b', 1, "bar");
    otherTable.put('a', 2, "baz");
    assertEquals(expectedTable, builder.putAll(otherTable).build());
  }

  public void testBuilder_withImmutableCell() {

   *
   * <p>For example, if {@code rangeMap} had the entries {@code [1, 5] => "foo", (6, 8) => "bar",
   * (10, ∞) => "baz"} then {@code rangeMap.subRangeMap(Range.open(3, 12))} would return a range map
   * with the entries {@code (3, 5] => "foo", (6, 8) => "bar", (10, 12) => "baz"}.
   *
   * <p>The returned range map supports all optional operations that this range map supports, except

    sink.writeLines(ImmutableList.of("foo", "bar", "baz").stream());
    String separator = System.getProperty("line.separator");
    assertEquals("foo" + separator + "bar" + separator + "baz" + separator, sink.getString());
  }

  public void testWriteLines_stream_separator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz").stream(), "!");
    assertEquals("foo!bar!baz!", sink.getString());
  }

      }
    }.test();
  }

  private void checkFooBarBazList(List<String> list) {
    assertThat(list).containsExactly("foo", "bar", "baz").inOrder();
    assertEquals(3, list.size());
    assertIndexIsOutOfBounds(list, -1);
    assertEquals("foo", list.get(0));
    assertEquals("bar", list.get(1));
    assertEquals("baz", list.get(2));

    assertThrows(NegativeArraySizeException.class, () -> Atomics.newReferenceArray(-1));
  }

  public void testNewReferenceArray_withStringArray() throws Exception {
    String[] array = {"foo", "bar", "baz"};
    AtomicReferenceArray<String> refArray = Atomics.newReferenceArray(array);
    for (int i = 0; i < array.length; ++i) {
      assertEquals(array[i], refArray.get(i));
    }

    assertThrows(NegativeArraySizeException.class, () -> Atomics.newReferenceArray(-1));
  }

  public void testNewReferenceArray_withStringArray() throws Exception {
    String[] array = {"foo", "bar", "baz"};
    AtomicReferenceArray<String> refArray = Atomics.newReferenceArray(array);
    for (int i = 0; i < array.length; ++i) {
      assertEquals(array[i], refArray.get(i));
    }

    }

    /**
     *
     */
    public interface Bar extends Foo<Integer, Long> {
    }

    /**
     * @param <T1>
     * @param <T2>
     *
     */
    public interface Baz<T1, T2> {

        /**
         * @return T1
         */
        T1[] array();

        /**
         * @return List
         */
        List<T2> list();

        /**

        assertThat(ReverseTreeRepositoryListener.lookupCollectStepData(doesNotHaveIt), nullValue());

        final CollectStepData data = mock(CollectStepData.class);

        RequestTrace haveItFirst = RequestTrace.newChild(null, data)
                .newChild("foo")
                .newChild("bar")
                .newChild("baz");

    sink.writeLines(ImmutableList.of("foo", "bar", "baz"), "\n");
    assertEquals("foo\nbar\nbaz\n", sink.getString());
  }

  public void testWriteLines_withDefaultSeparator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz"));
    String separator = System.getProperty("line.separator");
    assertEquals("foo" + separator + "bar" + separator + "baz" + separator, sink.getString());
  }

        assertTrue(UriTypeValidator.check(protocols, values));

        protocols = new String[] { "http:" };
        values = "http://www.foo.com/\nhttp://www.bar.com/\n http://www.baz.com/";
        assertTrue(UriTypeValidator.check(protocols, values));

        protocols = new String[] { "http:", "https:" };
        values = "https://www.foo.com/";