diff --git a/user/super/com/google/gwt/emul/java/util/Arrays.java b/user/super/com/google/gwt/emul/java/util/Arrays.java
index aef8ac0..72da442 100644
--- a/user/super/com/google/gwt/emul/java/util/Arrays.java
+++ b/user/super/com/google/gwt/emul/java/util/Arrays.java
@@ -19,13 +19,21 @@
 import static javaemul.internal.Coercions.ensureInt;
 import static javaemul.internal.InternalPreconditions.checkArgument;
 import static javaemul.internal.InternalPreconditions.checkArraySize;
+import static javaemul.internal.InternalPreconditions.checkCriticalArrayBounds;
 import static javaemul.internal.InternalPreconditions.checkCriticalPositionIndexes;
 import static javaemul.internal.InternalPreconditions.checkElementIndex;
 import static javaemul.internal.InternalPreconditions.checkNotNull;
-import static javaemul.internal.InternalPreconditions.checkPositionIndexes;
 
 import java.io.Serializable;
+import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntFunction;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.LongBinaryOperator;
 import java.util.function.UnaryOperator;
 
 import javaemul.internal.ArrayHelper;
@@ -129,15 +137,27 @@
    * Perform a binary search on a sorted byte array.
    *
    * @param sortedArray byte array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
    *         of the array if the searched value is larger than all elements in
    *         the array) minus 1 (to ensure error returns are negative)
    */
-  public static int binarySearch(final byte[] sortedArray, final byte key) {
-    int low = 0;
-    int high = sortedArray.length - 1;
+  public static int binarySearch(byte[] sortedArray, int fromIndex, int toIndex, byte key) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key);
+  }
+
+  public static int binarySearch(byte[] sortedArray, byte key) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key);
+  }
+
+  private static int binarySearch0(final byte[] sortedArray, int fromIndex, int toIndex,
+      final byte key) {
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
@@ -159,20 +179,32 @@
   /**
    * Perform a binary search on a sorted char array.
    *
-   * @param a char array to search
+   * @param sortedArray char array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
    *         of the array if the searched value is larger than all elements in
    *         the array) minus 1 (to ensure error returns are negative)
    */
-  public static int binarySearch(final char[] a, final char key) {
-    int low = 0;
-    int high = a.length - 1;
+  public static int binarySearch(char[] sortedArray, int fromIndex, int toIndex, char key) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key);
+  }
+
+  public static int binarySearch(char[] sortedArray, char key) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key);
+  }
+
+  private static int binarySearch0(final char[] sortedArray, int fromIndex, int toIndex,
+      final char key) {
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
-      final char midVal = a[mid];
+      final char midVal = sortedArray[mid];
 
       if (midVal < key) {
         low = mid + 1;
@@ -191,15 +223,27 @@
    * Perform a binary search on a sorted double array.
    *
    * @param sortedArray double array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
    *         of the array if the searched value is larger than all elements in
    *         the array) minus 1 (to ensure error returns are negative)
    */
-  public static int binarySearch(final double[] sortedArray, final double key) {
-    int low = 0;
-    int high = sortedArray.length - 1;
+  public static int binarySearch(double[] sortedArray, int fromIndex, int toIndex, double key) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key);
+  }
+
+  public static int binarySearch(double[] sortedArray, double key) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key);
+  }
+
+  private static int binarySearch0(final double[] sortedArray, int fromIndex, int toIndex,
+      final double key) {
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
@@ -227,15 +271,27 @@
    * to/from double may change the values slightly.
    *
    * @param sortedArray float array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
    *         of the array if the searched value is larger than all elements in
    *         the array) minus 1 (to ensure error returns are negative)
    */
-  public static int binarySearch(final float[] sortedArray, final float key) {
-    int low = 0;
-    int high = sortedArray.length - 1;
+  public static int binarySearch(float[] sortedArray, int fromIndex, int toIndex, float key) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key);
+  }
+
+  public static int binarySearch(float[] sortedArray, float key) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key);
+  }
+
+  private static int binarySearch0(final float[] sortedArray, int fromIndex, int toIndex,
+      final float key) {
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
@@ -258,15 +314,27 @@
    * Perform a binary search on a sorted int array.
    *
    * @param sortedArray int array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
    *         of the array if the searched value is larger than all elements in
    *         the array) minus 1 (to ensure error returns are negative)
    */
-  public static int binarySearch(final int[] sortedArray, final int key) {
-    int low = 0;
-    int high = sortedArray.length - 1;
+  public static int binarySearch(int[] sortedArray, int fromIndex, int toIndex, int key) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key);
+  }
+
+  public static int binarySearch(int[] sortedArray, int key) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key);
+  }
+
+  private static int binarySearch0(final int[] sortedArray, int fromIndex, int toIndex,
+      final int key) {
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
@@ -295,15 +363,27 @@
    * representable as doubles.
    *
    * @param sortedArray long array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
    *         of the array if the searched value is larger than all elements in
    *         the array) minus 1 (to ensure error returns are negative)
    */
-  public static int binarySearch(final long[] sortedArray, final long key) {
-    int low = 0;
-    int high = sortedArray.length - 1;
+  public static int binarySearch(long[] sortedArray, int fromIndex, int toIndex, long key) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key);
+  }
+
+  public static int binarySearch(long[] sortedArray, long key) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key);
+  }
+
+  private static int binarySearch0(final long[] sortedArray, int fromIndex, int toIndex,
+      final long key) {
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
@@ -326,6 +406,8 @@
    * Perform a binary search on a sorted object array, using natural ordering.
    *
    * @param sortedArray object array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
@@ -334,23 +416,39 @@
    * @throws ClassCastException if <code>key</code> is not comparable to
    *           <code>sortedArray</code>'s elements.
    */
-  public static int binarySearch(final Object[] sortedArray, final Object key) {
-    return binarySearch(sortedArray, key, Comparators.natural());
+  public static int binarySearch(Object[] sortedArray, int fromIndex, int toIndex, Object key) {
+    return binarySearch(sortedArray, fromIndex, toIndex, key, null);
+  }
+
+  public static int binarySearch(Object[] sortedArray, Object key) {
+    return binarySearch(sortedArray, key, null);
   }
 
   /**
    * Perform a binary search on a sorted short array.
    *
    * @param sortedArray short array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @return the index of an element with a matching value, or a negative number
    *         which is the index of the next larger value (or just past the end
    *         of the array if the searched value is larger than all elements in
    *         the array) minus 1 (to ensure error returns are negative)
    */
-  public static int binarySearch(final short[] sortedArray, final short key) {
-    int low = 0;
-    int high = sortedArray.length - 1;
+  public static int binarySearch(short[] sortedArray, int fromIndex, int toIndex, short key) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key);
+  }
+
+  public static int binarySearch(short[] sortedArray, short key) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key);
+  }
+
+  private static int binarySearch0(final short[] sortedArray, int fromIndex, int toIndex,
+      final short key) {
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
@@ -374,6 +472,8 @@
    * comparison function.
    *
    * @param sortedArray object array to search
+   * @param fromIndex index of the first element to search
+   * @param toIndex index (exclusive) of the last element to search
    * @param key value to search for
    * @param comparator comparision function, <code>null</code> indicates
    *          <i>natural ordering</i> should be used.
@@ -385,13 +485,23 @@
    *           <code>sortedArray</code>'s elements cannot be compared by
    *           <code>comparator</code>.
    */
-  public static <T> int binarySearch(final T[] sortedArray, final T key,
+  public static <T> int binarySearch(T[] sortedArray, int fromIndex, int toIndex, T key,
       Comparator<? super T> comparator) {
+    checkCriticalArrayBounds(fromIndex, toIndex, sortedArray.length);
+    return binarySearch0(sortedArray, fromIndex, toIndex, key, comparator);
+  }
+
+  public static <T> int binarySearch(T[] sortedArray, T key, Comparator<? super T> c) {
+    return binarySearch0(sortedArray, 0, sortedArray.length, key, c);
+  }
+
+  private static <T> int binarySearch0(final T[] sortedArray, int fromIndex, int toIndex,
+      final T key, Comparator<? super T> comparator) {
     if (comparator == null) {
       comparator = Comparators.natural();
     }
-    int low = 0;
-    int high = sortedArray.length - 1;
+    int low = fromIndex;
+    int high = toIndex - 1;
 
     while (low <= high) {
       final int mid = low + ((high - low) >> 1);
@@ -788,93 +898,138 @@
   }
 
   public static void fill(boolean[] a, boolean val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(boolean[] a, int fromIndex, int toIndex, boolean val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(byte[] a, byte val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(byte[] a, int fromIndex, int toIndex, byte val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(char[] a, char val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(char[] a, int fromIndex, int toIndex, char val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(char[] a, int fromIndex, int toIndex, char val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(double[] a, double val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(double[] a, int fromIndex, int toIndex, double val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(double[] a, int fromIndex, int toIndex, double val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(float[] a, float val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(float[] a, int fromIndex, int toIndex, float val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(float[] a, int fromIndex, int toIndex, float val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(int[] a, int val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(int[] a, int fromIndex, int toIndex, int val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(int[] a, int fromIndex, int toIndex, int val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(long[] a, int fromIndex, int toIndex, long val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(long[] a, int fromIndex, int toIndex, long val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(long[] a, long val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(Object[] a, int fromIndex, int toIndex, Object val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(Object[] a, Object val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static void fill(short[] a, int fromIndex, int toIndex, short val) {
+    checkCriticalArrayBounds(fromIndex, toIndex, a.length);
+    fill0(a, fromIndex, toIndex, val);
+  }
+
+  private static void fill0(short[] a, int fromIndex, int toIndex, short val) {
     for (int i = fromIndex; i < toIndex; ++i) {
       a[i] = val;
     }
   }
 
   public static void fill(short[] a, short val) {
-    fill(a, 0, a.length, val);
+    fill0(a, 0, a.length, val);
   }
 
   public static int hashCode(boolean[] a) {
@@ -985,12 +1140,132 @@
     return hashCode;
   }
 
+  public static void parallelPrefix(double[] array, DoubleBinaryOperator op) {
+    parallelPrefix0(array, 0, array.length, op);
+  }
+
+  public static void parallelPrefix(double[] array, int fromIndex, int toIndex,
+      DoubleBinaryOperator op) {
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
+    parallelPrefix0(array, fromIndex, toIndex, op);
+  }
+
+  private static void parallelPrefix0(double[] array, int fromIndex, int toIndex,
+      DoubleBinaryOperator op) {
+    checkNotNull(op);
+    double acc = array[fromIndex];
+    for (int i = fromIndex + 1; i < toIndex; i++) {
+      array[i] = acc = op.applyAsDouble(acc, array[i]);
+    }
+  }
+
+  public static void parallelPrefix(int[] array, IntBinaryOperator op) {
+    parallelPrefix0(array, 0, array.length, op);
+  }
+
+  public static void parallelPrefix(int[] array, int fromIndex, int toIndex,
+      IntBinaryOperator op) {
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
+    parallelPrefix0(array, fromIndex, toIndex, op);
+  }
+
+  private static void parallelPrefix0(int[] array, int fromIndex, int toIndex,
+      IntBinaryOperator op) {
+    checkNotNull(op);
+    int acc = array[fromIndex];
+    for (int i = fromIndex + 1; i < toIndex; i++) {
+      array[i] = acc = op.applyAsInt(acc, array[i]);
+    }
+  }
+
+  public static void parallelPrefix(long[] array, LongBinaryOperator op) {
+    parallelPrefix0(array, 0, array.length, op);
+  }
+
+  public static void parallelPrefix(long[] array, int fromIndex, int toIndex,
+      LongBinaryOperator op) {
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
+    parallelPrefix0(array, fromIndex, toIndex, op);
+  }
+
+  private static void parallelPrefix0(long[] array, int fromIndex, int toIndex,
+      LongBinaryOperator op) {
+    checkNotNull(op);
+    long acc = array[fromIndex];
+    for (int i = fromIndex + 1; i < toIndex; i++) {
+      array[i] = acc = op.applyAsLong(acc, array[i]);
+    }
+  }
+
+  public static <T> void parallelPrefix(T[] array, BinaryOperator<T> op) {
+    parallelPrefix0(array, 0, array.length, op);
+  }
+
+  public static <T> void parallelPrefix(T[] array, int fromIndex, int toIndex,
+      BinaryOperator<T> op) {
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
+    parallelPrefix0(array, fromIndex, toIndex, op);
+  }
+
+  private static <T> void parallelPrefix0(T[] array, int fromIndex, int toIndex,
+      BinaryOperator<T> op) {
+    checkNotNull(op);
+    T acc = array[fromIndex];
+    for (int i = fromIndex + 1; i < toIndex; i++) {
+      array[i] = acc = op.apply(acc, array[i]);
+    }
+  }
+
+  public static <T> void setAll(T[] array, IntFunction<? extends T> generator) {
+    checkNotNull(generator);
+    for (int i = 0; i < array.length; i++) {
+      array[i] = generator.apply(i);
+    }
+  }
+
+  public static void setAll(double[] array, IntToDoubleFunction generator) {
+    checkNotNull(generator);
+    for (int i = 0; i < array.length; i++) {
+      array[i] = generator.applyAsDouble(i);
+    }
+  }
+
+  public static void setAll(int[] array, IntUnaryOperator generator) {
+    checkNotNull(generator);
+    for (int i = 0; i < array.length; i++) {
+      array[i] = generator.applyAsInt(i);
+    }
+  }
+
+  public static void setAll(long[] array, IntToLongFunction generator) {
+    checkNotNull(generator);
+    for (int i = 0; i < array.length; i++) {
+      array[i] = generator.applyAsLong(i);
+    }
+  }
+
+  public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator) {
+    setAll(array, generator);
+  }
+
+  public static void parallelSetAll(double[] array, IntToDoubleFunction generator) {
+    setAll(array, generator);
+  }
+
+  public static void parallelSetAll(int[] array, IntUnaryOperator generator) {
+    setAll(array, generator);
+  }
+
+  public static void parallelSetAll(long[] array, IntToLongFunction generator) {
+    setAll(array, generator);
+  }
+
   public static void sort(byte[] array) {
     nativeNumberSort(array);
   }
 
   public static void sort(byte[] array, int fromIndex, int toIndex) {
-    checkPositionIndexes(fromIndex, toIndex, array.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
     nativeNumberSort(array, fromIndex, toIndex);
   }
 
@@ -999,7 +1274,7 @@
   }
 
   public static void sort(char[] array, int fromIndex, int toIndex) {
-    checkPositionIndexes(fromIndex, toIndex, array.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
     nativeNumberSort(array, fromIndex, toIndex);
   }
 
@@ -1008,7 +1283,7 @@
   }
 
   public static void sort(double[] array, int fromIndex, int toIndex) {
-    checkPositionIndexes(fromIndex, toIndex, array.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
     nativeNumberSort(array, fromIndex, toIndex);
   }
 
@@ -1017,7 +1292,7 @@
   }
 
   public static void sort(float[] array, int fromIndex, int toIndex) {
-    checkPositionIndexes(fromIndex, toIndex, array.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
     nativeNumberSort(array, fromIndex, toIndex);
   }
 
@@ -1026,7 +1301,7 @@
   }
 
   public static void sort(int[] array, int fromIndex, int toIndex) {
-    checkPositionIndexes(fromIndex, toIndex, array.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
     nativeNumberSort(array, fromIndex, toIndex);
   }
 
@@ -1035,16 +1310,16 @@
   }
 
   public static void sort(long[] array, int fromIndex, int toIndex) {
-    checkPositionIndexes(fromIndex, toIndex, array.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
     nativeLongSort(array, fromIndex, toIndex);
   }
 
   public static void sort(Object[] array) {
-    mergeSort(array, 0, array.length, Comparators.natural());
+    sort(array, null);
   }
 
-  public static void sort(Object[] x, int fromIndex, int toIndex) {
-    mergeSort(x, fromIndex, toIndex, Comparators.natural());
+  public static void sort(Object[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex, null);
   }
 
   public static void sort(short[] array) {
@@ -1052,7 +1327,7 @@
   }
 
   public static void sort(short[] array, int fromIndex, int toIndex) {
-    checkPositionIndexes(fromIndex, toIndex, array.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, array.length);
     nativeNumberSort(array, fromIndex, toIndex);
   }
 
@@ -1062,10 +1337,84 @@
 
   public static <T> void sort(T[] x, int fromIndex, int toIndex,
       Comparator<? super T> c) {
-    checkPositionIndexes(fromIndex, toIndex, x.length);
+    checkCriticalArrayBounds(fromIndex, toIndex, x.length);
     mergeSort(x, fromIndex, toIndex, c);
   }
 
+  public static void parallelSort(byte[] array) {
+    sort(array);
+  }
+
+  public static void parallelSort(byte[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static void parallelSort(char[] array) {
+    sort(array);
+  }
+
+  public static void parallelSort(char[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static void parallelSort(double[] array) {
+    sort(array);
+  }
+
+  public static void parallelSort(double[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static void parallelSort(float[] array) {
+    sort(array);
+  }
+
+  public static void parallelSort(float[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static void parallelSort(int[] array) {
+    sort(array);
+  }
+
+  public static void parallelSort(int[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static void parallelSort(long[] array) {
+    sort(array);
+  }
+
+  public static void parallelSort(long[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static void parallelSort(short[] array) {
+    sort(array);
+  }
+
+  public static void parallelSort(short[] array, int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static <T extends Comparable<? super T>> void parallelSort(T[] array) {
+    sort(array);
+  }
+
+  public static <T> void parallelSort(T[] array, Comparator<? super T> c) {
+    sort(array, c);
+  }
+
+  public static <T extends Comparable<? super T>> void parallelSort(T[] array,
+      int fromIndex, int toIndex) {
+    sort(array, fromIndex, toIndex);
+  }
+
+  public static <T> void parallelSort(T[] array, int fromIndex, int toIndex,
+      Comparator<? super T> c) {
+    sort(array, fromIndex, toIndex, c);
+  }
+
   public static Spliterator.OfDouble spliterator(double[] array) {
     return Spliterators.spliterator(array, Spliterator.IMMUTABLE | Spliterator.ORDERED);
   }
diff --git a/user/test/com/google/gwt/emultest/EmulJava8Suite.java b/user/test/com/google/gwt/emultest/EmulJava8Suite.java
index ae851bc..62c6526 100644
--- a/user/test/com/google/gwt/emultest/EmulJava8Suite.java
+++ b/user/test/com/google/gwt/emultest/EmulJava8Suite.java
@@ -17,6 +17,7 @@
 
 import com.google.gwt.emultest.java8.math.BigIntegerConvertTest;
 import com.google.gwt.emultest.java8.util.ArrayListTest;
+import com.google.gwt.emultest.java8.util.ArraysTest;
 import com.google.gwt.emultest.java8.util.ComparatorTest;
 import com.google.gwt.emultest.java8.util.DoubleSummaryStatisticsTest;
 import com.google.gwt.emultest.java8.util.HashMapTest;
@@ -53,6 +54,7 @@
     suite.addTestSuite(BigIntegerConvertTest.class);
 
     //-- java.util
+    suite.addTestSuite(ArraysTest.class);
     suite.addTestSuite(ArrayListTest.class);
     suite.addTestSuite(LinkedListTest.class);
     suite.addTestSuite(ListTest.class);
diff --git a/user/test/com/google/gwt/emultest/java/util/ArraysTest.java b/user/test/com/google/gwt/emultest/java/util/ArraysTest.java
index 20e095e..a9a79c7 100644
--- a/user/test/com/google/gwt/emultest/java/util/ArraysTest.java
+++ b/user/test/com/google/gwt/emultest/java/util/ArraysTest.java
@@ -16,6 +16,7 @@
 package com.google.gwt.emultest.java.util;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
@@ -201,11 +202,13 @@
     byte[] a1 = {};
     int ret = Arrays.binarySearch(a1, (byte) 0);
     assertEquals(-1, ret);
+
     byte[] a2 = {1, 7, 31};
     ret = Arrays.binarySearch(a2, (byte) 3);
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, (byte) 31);
     assertEquals(2, ret);
+
     byte[] a3 = {-71, 0, 35, 36};
     ret = Arrays.binarySearch(a3, (byte) 42);
     assertEquals(-5, ret);
@@ -213,6 +216,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, (byte) -71);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, (byte) 35);
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, (byte) -71);
+    assertEquals(-2, ret);
   }
 
   /**
@@ -231,11 +238,13 @@
     char[] a1 = {};
     int ret = Arrays.binarySearch(a1, (char) 0);
     assertEquals(-1, ret);
+
     char[] a2 = {1, 7, 31};
     ret = Arrays.binarySearch(a2, (char) 3);
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, (char) 31);
     assertEquals(2, ret);
+
     char[] a3 = {1, 2, 35, 36};
     ret = Arrays.binarySearch(a3, (char) 42);
     assertEquals(-5, ret);
@@ -243,6 +252,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, (char) 1);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, (char) 35);
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, (char) 1);
+    assertEquals(-2, ret);
   }
 
   /**
@@ -262,11 +275,13 @@
     double[] a1 = {};
     int ret = Arrays.binarySearch(a1, 0);
     assertEquals(-1, ret);
+
     double[] a2 = {1, 7, 31};
     ret = Arrays.binarySearch(a2, 3);
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, 31);
     assertEquals(2, ret);
+
     double[] a3 = {-71, 0, 35, 36};
     ret = Arrays.binarySearch(a3, 42);
     assertEquals(-5, ret);
@@ -274,6 +289,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, -71);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, 35);
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, -71);
+    assertEquals(-2, ret);
   }
 
   /**
@@ -293,11 +312,13 @@
     float[] a1 = {};
     int ret = Arrays.binarySearch(a1, 0);
     assertEquals(-1, ret);
+
     float[] a2 = {1, 7, 31};
     ret = Arrays.binarySearch(a2, 3);
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, 31);
     assertEquals(2, ret);
+
     float[] a3 = {-71, 0, 35, 36};
     ret = Arrays.binarySearch(a3, 42);
     assertEquals(-5, ret);
@@ -305,6 +326,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, -71);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, 35);
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, -71);
+    assertEquals(-2, ret);
   }
 
   /**
@@ -324,11 +349,13 @@
     int[] a1 = {};
     int ret = Arrays.binarySearch(a1, 0);
     assertEquals(-1, ret);
+
     int[] a2 = {1, 7, 31};
     ret = Arrays.binarySearch(a2, 3);
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, 31);
     assertEquals(2, ret);
+
     int[] a3 = {-71, 0, 35, 36};
     ret = Arrays.binarySearch(a3, 42);
     assertEquals(-5, ret);
@@ -336,6 +363,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, -71);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, 35);
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, -71);
+    assertEquals(-2, ret);
   }
 
   /**
@@ -355,11 +386,13 @@
     long[] a1 = {};
     int ret = Arrays.binarySearch(a1, 0L);
     assertEquals(-1, ret);
+
     long[] a2 = {1, 7, 31};
     ret = Arrays.binarySearch(a2, 3L);
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, 31L);
     assertEquals(2, ret);
+
     long[] a3 = {-71, 0, 35, 36};
     ret = Arrays.binarySearch(a3, 42L);
     assertEquals(-5, ret);
@@ -367,6 +400,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, -71L);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, 35);
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, -71);
+    assertEquals(-2, ret);
   }
 
   /**
@@ -385,11 +422,13 @@
     Object[] a1 = {};
     int ret = Arrays.binarySearch(a1, "");
     assertEquals(-1, ret);
+
     Object[] a2 = {"a", "g", "y"};
     ret = Arrays.binarySearch(a2, "c");
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, "y");
     assertEquals(2, ret);
+
     Object[] a3 = {"b", "c", "x", "y"};
     ret = Arrays.binarySearch(a3, "z");
     assertEquals(-5, ret);
@@ -397,6 +436,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, "b");
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, "x");
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, "b");
+    assertEquals(-2, ret);
   }
 
   /**
@@ -414,20 +457,17 @@
    */
   @SuppressWarnings("unchecked")
   public void testBinarySearchObjectComparator() {
-    Comparator inverseSort = new Comparator() {
-      @Override
-      public int compare(Object o1, Object o2) {
-        return ((Comparable) o2).compareTo(o1);
-      }
-    };
+    final Comparator inverseSort = Collections.reverseOrder();
     Object[] a1 = {};
     int ret = Arrays.binarySearch(a1, "", inverseSort);
     assertEquals(-1, ret);
+
     Object[] a2 = {"y", "g", "a"};
     ret = Arrays.binarySearch(a2, "c", inverseSort);
     assertEquals(-3, ret);
     ret = Arrays.binarySearch(a2, "a", inverseSort);
     assertEquals(2, ret);
+
     Object[] a3 = {"y", "x", "c", "b"};
     ret = Arrays.binarySearch(a3, "a", inverseSort);
     assertEquals(-5, ret);
@@ -435,6 +475,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, "y", inverseSort);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 3, "x", inverseSort);
+    assertEquals(1, ret);
+    ret = Arrays.binarySearch(a3, 1, 3, "b", inverseSort);
+    assertEquals(-4, ret);
 
     Object[] a4 = {"a", "b", "c", "d", "e"};
     ret = Arrays.binarySearch(a4, "d", null); // should not NPE
@@ -458,11 +502,13 @@
     short[] a1 = {};
     int ret = Arrays.binarySearch(a1, (short) 0);
     assertEquals(-1, ret);
+
     short[] a2 = {1, 7, 31};
     ret = Arrays.binarySearch(a2, (short) 3);
     assertEquals(-2, ret);
     ret = Arrays.binarySearch(a2, (short) 31);
     assertEquals(2, ret);
+
     short[] a3 = {-71, 0, 35, 36};
     ret = Arrays.binarySearch(a3, (short) 42);
     assertEquals(-5, ret);
@@ -470,6 +516,10 @@
     assertEquals(-1, ret);
     ret = Arrays.binarySearch(a3, (short) -71);
     assertEquals(0, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, (short) 35);
+    assertEquals(2, ret);
+    ret = Arrays.binarySearch(a3, 1, 4, (short) -71);
+    assertEquals(-2, ret);
   }
 
   /**
@@ -1159,14 +1209,29 @@
    * Tests sorting of long primitives.
    */
   public void testLongSort() {
-    long[] x = {3, 11, 2, 1, 22, 3};
-    Arrays.sort(x);
-    assertEquals(1, x[0]);
-    assertEquals(2, x[1]);
-    assertEquals(3, x[2]);
-    assertEquals(3, x[3]);
-    assertEquals(11, x[4]);
-    assertEquals(22, x[5]);
+    long[] array = new long[0];
+    Arrays.sort(array);
+
+    array = new long[]{Long.MIN_VALUE, 1, 2, 3, Long.MAX_VALUE};
+    Arrays.sort(array);
+    assertTrue(Arrays.equals(new long[]{Long.MIN_VALUE, 1, 2, 3, Long.MAX_VALUE}, array));
+
+    array = new long[]{3, Long.MAX_VALUE, 3, 2, 1, Long.MIN_VALUE};
+    Arrays.sort(array);
+    assertTrue(Arrays.equals(new long[]{Long.MIN_VALUE, 1, 2, 3, 3, Long.MAX_VALUE}, array));
+  }
+
+  /**
+   * Tests sorting of long primitives sub-range.
+   */
+  public void testLongSubrangeSort() {
+    long[] array = new long[]{3, Long.MAX_VALUE, 3, 2, 1, Long.MIN_VALUE};
+    Arrays.sort(array, 2, 5);
+    assertTrue(Arrays.equals(new long[]{3, Long.MAX_VALUE, 1, 2, 3, Long.MIN_VALUE}, array));
+
+    array = new long[]{3, Long.MAX_VALUE, 3, 2, 1, Long.MIN_VALUE};
+    Arrays.sort(array, 0, 0);
+    assertTrue(Arrays.equals(new long[]{3, Long.MAX_VALUE, 3, 2, 1, Long.MIN_VALUE}, array));
   }
 
   /**
@@ -1183,28 +1248,29 @@
    * Tests sorting primitives.
    */
   public void testPrimitiveSort() {
-    int[] x = {3, 11, 2, 1, 22, 3};
-    Arrays.sort(x);
-    assertEquals(1, x[0]);
-    assertEquals(2, x[1]);
-    assertEquals(3, x[2]);
-    assertEquals(3, x[3]);
-    assertEquals(11, x[4]);
-    assertEquals(22, x[5]);
+    int[] array = new int[0];
+    Arrays.sort(array);
+
+    array = new int[]{Integer.MIN_VALUE, 1, 2, 3, Integer.MAX_VALUE};
+    Arrays.sort(array);
+    assertTrue(Arrays.equals(new int[]{Integer.MIN_VALUE, 1, 2, 3, Integer.MAX_VALUE}, array));
+
+    array = new int[]{3, Integer.MAX_VALUE, 3, 2, 1, Integer.MIN_VALUE};
+    Arrays.sort(array);
+    assertTrue(Arrays.equals(new int[]{Integer.MIN_VALUE, 1, 2, 3, 3, Integer.MAX_VALUE}, array));
   }
 
   /**
    * Tests sorting a subrange of a primitive array.
    */
   public void testPrimitiveSubrangeSort() {
-    int[] x = {3, 11, 2, 1, 22, 3};
-    Arrays.sort(x, 1, 5);
-    assertEquals(3, x[0]);
-    assertEquals(1, x[1]);
-    assertEquals(2, x[2]);
-    assertEquals(11, x[3]);
-    assertEquals(22, x[4]);
-    assertEquals(3, x[5]);
+    int[] array = new int[]{3, Integer.MAX_VALUE, 3, 2, 1, Integer.MIN_VALUE};
+    Arrays.sort(array, 2, 5);
+    assertTrue(Arrays.equals(new int[]{3, Integer.MAX_VALUE, 1, 2, 3, Integer.MIN_VALUE}, array));
+
+    array = new int[]{3, Integer.MAX_VALUE, 3, 2, 1, Integer.MIN_VALUE};
+    Arrays.sort(array, 0, 0);
+    assertTrue(Arrays.equals(new int[]{3, Integer.MAX_VALUE, 3, 2, 1, Integer.MIN_VALUE}, array));
   }
 
   /**
@@ -1231,25 +1297,48 @@
    * Tests {@link Arrays#sort(Object[], Comparator)}.
    */
   public void testSort() {
-    Object[] x = {"c", "b", "b", "a"};
-    int hash = x[1].hashCode();
-    Arrays.sort(x);
-    int hash2 = x[1].hashCode();
-    assertEquals(hash, hash2);
-    Object[] sorted = {"a", "b", "b", "c"};
-    assertEquals(x, sorted);
-    Comparator<Object> t = new Comparator<Object>() {
+    Object[] array = {"c", "b", "b", "a"};
+    Arrays.sort(array);
+    assertEquals(new Object[]{"a", "b", "b", "c"}, array);
+
+    array = new Object[]{"c", "b", "b", "a"};
+    Comparator<Object> natural = new Comparator<Object>() {
       @Override
       @SuppressWarnings("unchecked")
-      public int compare(Object o1, Object o2) {
-        return ((Comparable<Object>) o2).compareTo(o1);
+      public int compare(Object a, Object b) {
+        return ((Comparable<Object>) a).compareTo(b);
       }
     };
-    Arrays.sort(x, t);
-    int hash3 = x[1].hashCode();
-    assertEquals(hash, hash3);
-    Object[] reverseSorted = {"c", "b", "b", "a"};
-    assertEquals(x, reverseSorted);
+    Arrays.sort(array, natural);
+    assertEquals(new Object[]{"a", "b", "b", "c"}, array);
+
+    array = new Object[]{"c", "b", "b", "a"};
+    Arrays.sort(array, Collections.reverseOrder());
+    assertEquals(new Object[]{"c", "b", "b", "a"}, array);
+
+    array = new Object[]{"c", "b", "b", "a"};
+    Arrays.sort(array, null);
+    assertEquals(new Object[]{"a", "b", "b", "c"}, array);
+  }
+
+  /**
+   * Tests sorting of Object array sub-range.
+   */
+  public void testSortSubRange() {
+    Object[] array = {"c", "b", "b", "a"};
+    Arrays.sort(array, 0, 0);
+    assertEquals(new Object[]{"c", "b", "b", "a"}, array);
+
+    array = new Object[]{"c", "b", "b", "a"};
+    Arrays.sort(array, 1, 2);
+    assertEquals(new Object[]{"c", "b", "b", "a"}, array);
+
+    Arrays.sort(array, 1, 4);
+    assertEquals(new Object[]{"c", "a", "b", "b"}, array);
+
+    array = new Object[]{"c", "b", "b", "a"};
+    Arrays.sort(array, 1, 4, Collections.reverseOrder());
+    assertEquals(new Object[]{"c", "b", "b", "a"}, array);
   }
 
   /**
@@ -1261,6 +1350,17 @@
    * test.
    */
   public void testStableSort() {
+    Comparator<TestObject> comparator = new Comparator<TestObject>() {
+      @Override
+      public int compare(TestObject a, TestObject b) {
+        return a.getValue() - b.getValue();
+      }
+    };
+    testStableSort(comparator);
+    testStableSort(Collections.reverseOrder(comparator));
+  }
+
+  private void testStableSort(Comparator<TestObject> comparator) {
     TestObject[] origData = new TestObject[] {
         new TestObject(3), new TestObject(11), new TestObject(2),
         new TestObject(3), new TestObject(1), new TestObject(3),
@@ -1268,15 +1368,13 @@
     int[] permutation = new int[origData.length];
     while (validPermutation(permutation, origData.length)) {
       TestObject[] permutedArray = getPermutation(origData, permutation);
-      Arrays.sort(permutedArray, new Comparator<TestObject>() {
-        @Override
-        public int compare(TestObject a, TestObject b) {
-          return a.getValue() - b.getValue();
-        }
-      });
+      Arrays.sort(permutedArray, comparator);
       for (int i = 1; i < permutedArray.length; ++i) {
-        if (permutedArray[i - 1].getValue() > permutedArray[i].getValue()
-            || (permutedArray[i - 1].getValue() == permutedArray[i].getValue() && permutedArray[i - 1].getIndex() > permutedArray[i].getIndex())) {
+        TestObject prev = permutedArray[i - 1];
+        TestObject cur = permutedArray[i];
+        int cmp = comparator.compare(prev, cur);
+        if (cmp > 0
+            || (cmp == 0 && prev.getIndex() > cur.getIndex())) {
           String msg = "Permutation " + Arrays.toString(permutation) + ": "
               + Arrays.toString(permutedArray);
           permutedArray = getPermutation(origData, permutation);
@@ -1380,5 +1478,4 @@
     }
     return true;
   }
-
 }
diff --git a/user/test/com/google/gwt/emultest/java8/util/ArraysTest.java b/user/test/com/google/gwt/emultest/java8/util/ArraysTest.java
new file mode 100644
index 0000000..3a4d42b
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java8/util/ArraysTest.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.emultest.java8.util;
+
+import com.google.gwt.emultest.java.util.EmulTestBase;
+
+import java.util.Arrays;
+
+/**
+ * Java 8 methods to test in java.util.Arrays.
+ */
+public class ArraysTest extends EmulTestBase {
+
+  public void testParallelPrefix_double() {
+    double[] array = {1};
+    Arrays.parallelPrefix(array, Double::sum);
+    assertTrue(Arrays.equals(new double[]{1}, array));
+
+    array = new double[]{1, 2, 3};
+    Arrays.parallelPrefix(array, Double::sum);
+    assertTrue(Arrays.equals(new double[]{1, 3, 6}, array));
+
+    array = new double[]{1, 2, 3};
+    Arrays.parallelPrefix(array, 0, 0, Double::sum);
+    assertTrue(Arrays.equals(new double[]{1, 2, 3}, array));
+
+    array = new double[]{1, 2, 3, 4, 5};
+    Arrays.parallelPrefix(array, 1, 4, Double::sum);
+    assertTrue(Arrays.equals(new double[]{1, 2, 5, 9, 5}, array));
+  }
+
+  public void testParallelPrefix_int() {
+    int[] array = {1};
+    Arrays.parallelPrefix(array, Integer::sum);
+    assertTrue(Arrays.equals(new int[]{1}, array));
+
+    array = new int[]{1, 2, 3};
+    Arrays.parallelPrefix(array, Integer::sum);
+    assertTrue(Arrays.equals(new int[]{1, 3, 6}, array));
+
+    array = new int[]{1, 2, 3};
+    Arrays.parallelPrefix(array, 0, 0, Integer::sum);
+    assertTrue(Arrays.equals(new int[]{1, 2, 3}, array));
+
+    array = new int[]{1, 2, 3, 4, 5};
+    Arrays.parallelPrefix(array, 1, 4, Integer::sum);
+    assertTrue(Arrays.equals(new int[]{1, 2, 5, 9, 5}, array));
+  }
+
+  public void testParallelPrefix_long() {
+    long[] array = {1};
+    Arrays.parallelPrefix(array, Long::sum);
+    assertTrue(Arrays.equals(new long[]{1}, array));
+
+    array = new long[]{1, 2, 3};
+    Arrays.parallelPrefix(array, Long::sum);
+    assertTrue(Arrays.equals(new long[]{1, 3, 6}, array));
+
+    array = new long[]{1, 2, 3};
+    Arrays.parallelPrefix(array, 0, 0, Long::sum);
+    assertTrue(Arrays.equals(new long[]{1, 2, 3}, array));
+
+    array = new long[]{1, 2, 3, 4, 5};
+    Arrays.parallelPrefix(array, 1, 4, Long::sum);
+    assertTrue(Arrays.equals(new long[]{1, 2, 5, 9, 5}, array));
+  }
+
+  public void testParallelPrefix_Object() {
+    String[] array = {"a"};
+    Arrays.parallelPrefix(array, String::concat);
+    assertEquals(new String[]{"a"}, array);
+
+    array = new String[]{"a", "b", "c"};
+    Arrays.parallelPrefix(array, String::concat);
+    assertEquals(new String[]{"a", "ab", "abc"}, array);
+
+    array = new String[]{"a", "b", "c"};
+    Arrays.parallelPrefix(array, 0, 0, String::concat);
+    assertEquals(new String[]{"a", "b", "c"}, array);
+
+    array = new String[]{"a", "b", "c", "d", "e"};
+    Arrays.parallelPrefix(array, 1, 4, String::concat);
+    assertEquals(new String[]{"a", "b", "bc", "bcd", "e"}, array);
+  }
+
+  public void testSetAll_double() {
+    double[] array = {};
+    Arrays.setAll(array, i -> (double) i);
+    assertTrue(Arrays.equals(new double[0], array));
+
+    array = new double[]{0, 0, 0};
+    Arrays.setAll(array, i -> (double) i + 1);
+    assertTrue(Arrays.equals(new double[]{1, 2, 3}, array));
+  }
+
+  public void testSetAll_int() {
+    int[] array = {};
+    Arrays.setAll(array, i -> i);
+    assertTrue(Arrays.equals(new int[0], array));
+
+    array = new int[]{0, 0, 0};
+    Arrays.setAll(array, i -> i + 1);
+    assertTrue(Arrays.equals(new int[]{1, 2, 3}, array));
+  }
+
+  public void testSetAll_long() {
+    long[] array = {};
+    Arrays.setAll(array, i -> (long) i);
+    assertTrue(Arrays.equals(new long[0], array));
+
+    array = new long[]{0, 0, 0};
+    Arrays.setAll(array, i -> (long) i + 1);
+    assertTrue(Arrays.equals(new long[]{1, 2, 3}, array));
+  }
+
+  public void testSetAll_Object() {
+    String[] array = {};
+    Arrays.setAll(array, i -> "" + i);
+    assertEquals(new String[0], array);
+
+    array = new String[]{"a", "b", "c"};
+    Arrays.setAll(array, i -> "" + (i + 1));
+    assertEquals(new String[]{"1", "2", "3"}, array);
+  }
+}