}

  public void testCopyOf_arrayContainingOnlyNull() {
    @Nullable String[] array = new @Nullable String[] {null};
    assertThrows(NullPointerException.class, () -> ImmutableList.copyOf((String[]) array));
  }

  public void testCopyOf_collection_empty() {
    Collection<String> c = MinimalCollection.of();
    List<String> list = ImmutableList.copyOf(c);

      @Override
      public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
        return ImmutableSet.copyOf(contents);
      }
    },
    ImmutableSortedSetImpl {
      @Override
      public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
        return ImmutableSortedSet.copyOf(contents);
      }
    },
    ContiguousSetImpl {
      @Override

      rowBuilder.put(row.getKey(), ImmutableMap.copyOf(row.getValue()));
    }
    this.rowMap = rowBuilder.buildOrThrow();

    ImmutableMap.Builder<C, ImmutableMap<R, V>> columnBuilder =
        new ImmutableMap.Builder<>(columns.size());
    for (Entry<C, Map<R, V>> col : columns.entrySet()) {
      columnBuilder.put(col.getKey(), ImmutableMap.copyOf(col.getValue()));
    }

   *     ImmutableSortedMultiset#copyOf(Comparable[])}.</b>
   */
  @DoNotCall("Elements must be Comparable. (Or, pass a Comparator to orderedBy or copyOf.)")
  @Deprecated
  // The usage of "Z" here works around bugs in Javadoc (JDK-8318093) and JDiff.
  public static <Z> ImmutableSortedMultiset<Z> copyOf(Z[] elements) {
    throw new UnsupportedOperationException();
  }

    assertThat(immutableGraph).isNotInstanceOf(MutableValueGraph.class);
    assertThat(immutableGraph).isEqualTo(mutableGraph);

    mutableGraph.addNode("B");
    assertThat(immutableGraph).isNotEqualTo(mutableGraph);
  }

  @Test
  public void copyOfImmutableGraph_optimized() {
    Graph<String> graph1 = ImmutableGraph.copyOf(GraphBuilder.directed().<String>build());

  private ListGenerators() {}

  public static class ImmutableListOfGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      return ImmutableList.copyOf(elements);
    }
  }

  public static class BuilderAddListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {

                    Path rootDirectory) {
                this.userProperties = Map.copyOf(userProperties);
                this.systemProperties = Map.copyOf(systemProperties);
                Map<String, String> cp = new HashMap<>(systemProperties);
                cp.putAll(userProperties);
                this.effectiveProperties = Map.copyOf(cp);
                this.startTime = requireNonNull(startTime);

   * {@link Collection}, this method behaves exactly as {@link #copyOf(Collection)}; otherwise, it
   * behaves exactly as {@code copyOf(elements.iterator()}.
   *
   * @throws NullPointerException if {@code elements} contains a null element
   */
  public static <E> ImmutableList<E> copyOf(Iterable<? extends E> elements) {
    checkNotNull(elements); // TODO(kevinb): is this here only for GWT?

     */
    assertThat(ImmutableLongArray.copyOf(new long[0])).isSameInstanceAs(ImmutableLongArray.of());
  }

  public void testCopyOf_array_nonempty() {
    long[] array = new long[] {0, 1, 3};
    ImmutableLongArray iia = ImmutableLongArray.copyOf(array);
    array[2] = 2;
    assertThat(iia.asList()).containsExactly(0L, 1L, 3L).inOrder();
  }

  @Before
  public void createSets() {
    wrappedSet = new HashSet<>();
    wrappedSet.add(1);
    wrappedSet.add(2);
    wrappedSet.add(3);

    copyOfWrappedSet = ImmutableSet.copyOf(wrappedSet);
    setToTest =
        InvalidatableSet.of(wrappedSet, () -> wrappedSet.contains(1), () -> 1 + "is not present");
  }

  @Test
  @SuppressWarnings("TruthSelfEquals")
  public void testEquals() {