@BeforeExperiment
  void setUp() throws Exception {
    Random r = new Random();
    ba1 = new byte[length];
    r.nextBytes(ba1);
    ba2 = Arrays.copyOf(ba1, ba1.length);
    // Differ at the last element
    ba3 = Arrays.copyOf(ba1, ba1.length);
    ba4 = Arrays.copyOf(ba1, ba1.length);
    ba3[ba1.length - 1] = (byte) 43;
    ba4[ba1.length - 1] = (byte) 42;

    javaImpl = UnsignedBytes.lexicographicalComparatorJavaImpl();

  @Override
  protected <E extends Comparable<? super E>> Set<E> copyOf(E[] elements) {
    return ImmutableSet.copyOf(elements);
  }

  @Override
  protected <E extends Comparable<? super E>> Set<E> copyOf(Collection<? extends E> elements) {
    return ImmutableSet.copyOf(elements);
  }

  @Override
  protected <E extends Comparable<? super E>> Set<E> copyOf(Iterable<? extends E> elements) {

  @Override
  protected <E extends Comparable<? super E>> Set<E> copyOf(E[] elements) {
    return ImmutableSet.copyOf(elements);
  }

  @Override
  protected <E extends Comparable<? super E>> Set<E> copyOf(Collection<? extends E> elements) {
    return ImmutableSet.copyOf(elements);
  }

  @Override
  protected <E extends Comparable<? super E>> Set<E> copyOf(Iterable<? extends E> elements) {

  protected <E extends Comparable<? super E>> SortedSet<E> copyOf(E[] elements) {
    return ImmutableSortedSet.copyOf(elements);
  }

  @Override
  protected <E extends Comparable<? super E>> SortedSet<E> copyOf(
      Collection<? extends E> elements) {
    return ImmutableSortedSet.copyOf(elements);
  }

  @Override
  protected <E extends Comparable<? super E>> SortedSet<E> copyOf(Iterable<? extends E> elements) {

   * @deprecated Prefer {@code asCharSource(from, charset).copyTo(to)}.
   */
  @Deprecated
  @InlineMe(
      replacement = "Files.asCharSource(from, charset).copyTo(to)",
      imports = "com.google.common.io.Files")
  public
  static void copy(File from, Charset charset, Appendable to) throws IOException {
    asCharSource(from, charset).copyTo(to);
  }

  /**

  }

  public void testCopyOfEmptyMap() {
    ImmutableSortedMap<String, Integer> copy =
        ImmutableSortedMap.copyOf(Collections.<String, Integer>emptyMap());
    assertEquals(Collections.<String, Integer>emptyMap(), copy);
    assertThat(ImmutableSortedMap.copyOf(copy)).isSameInstanceAs(copy);
    assertThat(copy.comparator()).isEqualTo(Ordering.natural());
  }

  public void testCopyOfSingletonMap() {

  }

  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);

     */
    assertThat(ImmutableDoubleArray.copyOf(new double[0]))
        .isSameInstanceAs(ImmutableDoubleArray.of());
  }

  public void testCopyOf_array_nonempty() {
    double[] array = new double[] {0, 1, 3};
    ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(array);
    array[2] = 2;
    assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

  }

  private static ImmutableList<Integer> elements(Integer... elements) {
    return ImmutableList.copyOf(elements);
  }

  private static ImmutableList<ListFrobber> ops(ListFrobber... elements) {
    return ImmutableList.copyOf(elements);
  }

  public void testCopyOf_concurrentlyMutatedList() {
    runConcurrentlyMutatedTest(WrapWithIterable.NO_WRAP);
  }

      @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