void setUp() throws Exception {
    Random rng = new Random();
    for (int i = 0; i < 0x100; i++) {
      Integer[] array = new Integer[n];
      for (int j = 0; j < n; j++) {
        array[j] = rng.nextInt();
      }
      inputArrays[i] = array;
    }
  }

  @Benchmark
  int arraysSortNoComparator(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      Integer[] copy = inputArrays[i & 0xFF].clone();

            Object[] array = s.toArray();
            for (int i = 0; i < 2; i++) {
                assertEquals(values[i], array[i]);
            }
        });
    }

    public void test_ofNull() {
        assertEquals(0, (int) StreamUtil.stream().get(s -> s.toArray().length));
        Object[] o = {};
        assertEquals(0, (int) StreamUtil.stream(o).get(s -> s.toArray().length));

  }

  @GwtIncompatible // Iterators.toArray(Iterator, Class)
  public void testToArrayEmpty() {
    Iterator<String> iterator = Collections.<String>emptyList().iterator();
    String[] array = Iterators.toArray(iterator, String.class);
    assertTrue(Arrays.equals(new String[0], array));
  }

  @GwtIncompatible // Iterators.toArray(Iterator, Class)
  public void testToArraySingleton() {

  }

  static <T extends @Nullable Object> T[] toArray(Iterable<? extends T> iterable, T[] array) {
    Collection<? extends T> collection = castOrCopyToCollection(iterable);
    return collection.toArray(array);
  }

  /**
   * Copies an iterable's elements into an array.
   *
   * @param iterable the iterable to copy

  }

  /** Returns an int array of the specified size, filled with ABSENT. */
  private static int[] createFilledWithAbsent(int size) {
    int[] array = new int[size];
    Arrays.fill(array, ABSENT);
    return array;
  }

  /** Equivalent to {@code Arrays.copyOf(array, newSize)}, save that the new elements are ABSENT. */
  private static int[] expandAndFillWithAbsent(int[] array, int newSize) {

            // Additional passes with different patterns for enhanced security
            Arrays.fill(array, (byte) 0xFF);
            Arrays.fill(array, (byte) 0xAA);
            Arrays.fill(array, (byte) 0x55);
            Arrays.fill(array, (byte) 0);
        }
    }

     * Returns the method name.
     *
     * @return Method name
     */
    public String getMethodName() {
        return methodName;
    }

    /**
     * Returns the array of {@link Class} for the method arguments.
     *
     * @return Array of {@link Class} for the method arguments
     */
    public Class<?>[] getMethodArgClasses() {
        return methodArgClasses;
    }

  }

  public void testCopyOf_emptyArray() {
    String[] array = new String[0];
    Set<String> set = copyOf(array);
    assertEquals(Collections.<String>emptySet(), set);
    assertSame(this.<String>of(), set);
  }

  public void testCopyOf_arrayOfOneElement() {
    String[] array = new String[] {"a"};
    Set<String> set = copyOf(array);
    assertEquals(singleton("a"), set);
  }

                bytes[byteIndex++] = (byte) (0x80 | (c & 0x3F));
            }
        }

        return Arrays.copyOf(bytes, byteIndex);
    }

    /**
     * Convert byte array to char array (UTF-8)
     */
    private char[] bytesToChars(byte[] bytes) {
        if (bytes == null) {
            return null;
        }

        // Decode UTF-8

  public void testRetainAll_duplicatesKept() {
    E[] array = createSamplesArray();
    array[1] = e0();
    collection = getSubjectGenerator().create(array);
    assertFalse(
        "containsDuplicates.retainAll(superset) should return false",
        collection.retainAll(MinimalCollection.of(createSamplesArray())));
    expectContents(array);
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)