Add stubs for hiddenapi

Adds stubs for ojluni classes some of whose hidden members are used by
applications. Each such member is annotated with the UnsupportedAppUsage
annotation.

The stubs are built as part of the core-oj-hiddenapi target from which
the build will extract information about the hidden class members that
are used by applications.

This was tested by making and then manually checking that the generated
out/target/common/obj/PACKAGING/hiddenapi-light-greylist.txt was the
same (after sorting) before and after this change.

Test: see above
Bug: 117818301
Change-Id: Icfe773e00ba1f96a379b705f26ef631ec34fee5e

1 files changed, 831 insertions, 0 deletions

diff --git a/ojluni/annotations/hiddenapi/java/util/Arrays.java b/ojluni/annotations/hiddenapi/java/util/Arrays.java
new file mode 100644
index 0000000000..c763a2d538
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Arrays.java
@@ -0,0 +1,831 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Arrays {
+
+    private Arrays() {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(int[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(int[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(long[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(long[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(short[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(short[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(char[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(char[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(byte[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(byte[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(float[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(float[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(double[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(double[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(byte[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(byte[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(char[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(char[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(short[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(short[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(int[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(int[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(long[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(long[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(float[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(float[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(double[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSort(double[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T extends java.lang.Comparable<? super T>> void parallelSort(T[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T extends java.lang.Comparable<? super T>> void parallelSort(
+            T[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void parallelSort(T[] a, java.util.Comparator<? super T> cmp) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void parallelSort(
+            T[] a, int fromIndex, int toIndex, java.util.Comparator<? super T> cmp) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(java.lang.Object[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void sort(java.lang.Object[] a, int fromIndex, int toIndex) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static void mergeSort(
+            java.lang.Object[] src, java.lang.Object[] dest, int low, int high, int off) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static void swap(java.lang.Object[] x, int a, int b) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void sort(T[] a, java.util.Comparator<? super T> c) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void sort(
+            T[] a, int fromIndex, int toIndex, java.util.Comparator<? super T> c) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void parallelPrefix(T[] array, java.util.function.BinaryOperator<T> op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void parallelPrefix(
+            T[] array, int fromIndex, int toIndex, java.util.function.BinaryOperator<T> op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelPrefix(long[] array, java.util.function.LongBinaryOperator op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelPrefix(
+            long[] array, int fromIndex, int toIndex, java.util.function.LongBinaryOperator op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelPrefix(double[] array, java.util.function.DoubleBinaryOperator op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelPrefix(
+            double[] array,
+            int fromIndex,
+            int toIndex,
+            java.util.function.DoubleBinaryOperator op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelPrefix(int[] array, java.util.function.IntBinaryOperator op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelPrefix(
+            int[] array, int fromIndex, int toIndex, java.util.function.IntBinaryOperator op) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(long[] a, long key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(long[] a, int fromIndex, int toIndex, long key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(long[] a, int fromIndex, int toIndex, long key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(int[] a, int key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(int[] a, int fromIndex, int toIndex, int key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(short[] a, short key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(short[] a, int fromIndex, int toIndex, short key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(short[] a, int fromIndex, int toIndex, short key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(char[] a, char key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(char[] a, int fromIndex, int toIndex, char key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(char[] a, int fromIndex, int toIndex, char key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(byte[] a, byte key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(byte[] a, int fromIndex, int toIndex, byte key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(double[] a, double key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(double[] a, int fromIndex, int toIndex, double key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(double[] a, int fromIndex, int toIndex, double key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(float[] a, float key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(float[] a, int fromIndex, int toIndex, float key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(float[] a, int fromIndex, int toIndex, float key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(java.lang.Object[] a, java.lang.Object key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int binarySearch(
+            java.lang.Object[] a, int fromIndex, int toIndex, java.lang.Object key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static int binarySearch0(
+            java.lang.Object[] a, int fromIndex, int toIndex, java.lang.Object key) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> int binarySearch(T[] a, T key, java.util.Comparator<? super T> c) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> int binarySearch(
+            T[] a, int fromIndex, int toIndex, T key, java.util.Comparator<? super T> c) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static <T> int binarySearch0(
+            T[] a, int fromIndex, int toIndex, T key, java.util.Comparator<? super T> c) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(long[] a, long[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(int[] a, int[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(short[] a, short[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(char[] a, char[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(byte[] a, byte[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(boolean[] a, boolean[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(double[] a, double[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(float[] a, float[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean equals(java.lang.Object[] a, java.lang.Object[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(long[] a, long val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(long[] a, int fromIndex, int toIndex, long val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(int[] a, int val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(int[] a, int fromIndex, int toIndex, int val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(short[] a, short val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(short[] a, int fromIndex, int toIndex, short val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(char[] a, char val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(char[] a, int fromIndex, int toIndex, char val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(byte[] a, byte val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(boolean[] a, boolean val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(double[] a, double val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(double[] a, int fromIndex, int toIndex, double val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(float[] a, float val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(float[] a, int fromIndex, int toIndex, float val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(java.lang.Object[] a, java.lang.Object val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void fill(
+            java.lang.Object[] a, int fromIndex, int toIndex, java.lang.Object val) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> T[] copyOf(T[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T, U> T[] copyOf(
+            U[] original, int newLength, java.lang.Class<? extends T[]> newType) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static byte[] copyOf(byte[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static short[] copyOf(short[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int[] copyOf(int[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static long[] copyOf(long[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static char[] copyOf(char[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static float[] copyOf(float[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static double[] copyOf(double[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean[] copyOf(boolean[] original, int newLength) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> T[] copyOfRange(T[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T, U> T[] copyOfRange(
+            U[] original, int from, int to, java.lang.Class<? extends T[]> newType) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static byte[] copyOfRange(byte[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static short[] copyOfRange(short[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int[] copyOfRange(int[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static long[] copyOfRange(long[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static char[] copyOfRange(char[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static float[] copyOfRange(float[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static double[] copyOfRange(double[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean[] copyOfRange(boolean[] original, int from, int to) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> java.util.List<T> asList(T... a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(long[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(int[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(short[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(char[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(byte[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(boolean[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(float[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(double[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int hashCode(java.lang.Object[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int deepHashCode(java.lang.Object[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static boolean deepEquals(java.lang.Object[] a1, java.lang.Object[] a2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    static boolean deepEquals0(java.lang.Object e1, java.lang.Object e2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(long[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(int[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(short[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(char[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(byte[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(boolean[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(float[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(double[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String toString(java.lang.Object[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.lang.String deepToString(java.lang.Object[] a) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @UnsupportedAppUsage
+    private static void deepToString(
+            java.lang.Object[] a,
+            java.lang.StringBuilder buf,
+            java.util.Set<java.lang.Object[]> dejaVu) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void setAll(
+            T[] array, java.util.function.IntFunction<? extends T> generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> void parallelSetAll(
+            T[] array, java.util.function.IntFunction<? extends T> generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void setAll(int[] array, java.util.function.IntUnaryOperator generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSetAll(int[] array, java.util.function.IntUnaryOperator generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void setAll(long[] array, java.util.function.IntToLongFunction generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSetAll(
+            long[] array, java.util.function.IntToLongFunction generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void setAll(double[] array, java.util.function.IntToDoubleFunction generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static void parallelSetAll(
+            double[] array, java.util.function.IntToDoubleFunction generator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> java.util.Spliterator<T> spliterator(T[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> java.util.Spliterator<T> spliterator(
+            T[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.Spliterator.OfInt spliterator(int[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.Spliterator.OfInt spliterator(
+            int[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.Spliterator.OfLong spliterator(long[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.Spliterator.OfLong spliterator(
+            long[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.Spliterator.OfDouble spliterator(double[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.Spliterator.OfDouble spliterator(
+            double[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> java.util.stream.Stream<T> stream(T[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static <T> java.util.stream.Stream<T> stream(
+            T[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.stream.IntStream stream(int[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.stream.IntStream stream(
+            int[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.stream.LongStream stream(long[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.stream.LongStream stream(
+            long[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.stream.DoubleStream stream(double[] array) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static java.util.stream.DoubleStream stream(
+            double[] array, int startInclusive, int endExclusive) {
+        throw new RuntimeException("Stub!");
+    }
+
+    private static final int INSERTIONSORT_THRESHOLD = 7; // 0x7
+
+    public static final int MIN_ARRAY_SORT_GRAN = 8192; // 0x2000
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    private static class ArrayList<E> extends java.util.AbstractList<E>
+            implements java.util.RandomAccess, java.io.Serializable {
+
+        ArrayList(E[] array) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public int size() {
+            throw new RuntimeException("Stub!");
+        }
+
+        public java.lang.Object[] toArray() {
+            throw new RuntimeException("Stub!");
+        }
+
+        public <T> T[] toArray(T[] a) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public E get(int index) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public E set(int index, E element) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public int indexOf(java.lang.Object o) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public boolean contains(java.lang.Object o) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public java.util.Spliterator<E> spliterator() {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void forEach(java.util.function.Consumer<? super E> action) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void sort(java.util.Comparator<? super E> c) {
+            throw new RuntimeException("Stub!");
+        }
+
+        @UnsupportedAppUsage
+        private final E[] a;
+
+        {
+            a = null;
+        }
+
+        private static final long serialVersionUID = -2764017481108945198L; // 0xd9a43cbecd8806d2L
+    }
+
+    @SuppressWarnings({"unchecked", "deprecation", "all"})
+    static final class NaturalOrder implements java.util.Comparator<java.lang.Object> {
+
+        NaturalOrder() {
+            throw new RuntimeException("Stub!");
+        }
+
+        public int compare(java.lang.Object first, java.lang.Object second) {
+            throw new RuntimeException("Stub!");
+        }
+
+        static final java.util.Arrays.NaturalOrder INSTANCE;
+
+        static {
+            INSTANCE = null;
+        }
+    }
+}