diff --git a/user/super/com/google/gwt/emul/java/lang/Byte.java b/user/super/com/google/gwt/emul/java/lang/Byte.java
index 2d9a99b..bc87eed 100644
--- a/user/super/com/google/gwt/emul/java/lang/Byte.java
+++ b/user/super/com/google/gwt/emul/java/lang/Byte.java
@@ -23,6 +23,7 @@
   public static final byte MIN_VALUE = (byte) 0x80;
   public static final byte MAX_VALUE = (byte) 0x7F;
   public static final int SIZE = 8;
+  public static final int BYTES = SIZE / Byte.SIZE;
   public static final Class<Byte> TYPE = byte.class;
 
   /**
@@ -41,11 +42,6 @@
     return Byte.valueOf((byte) __decodeAndValidateInt(s, MIN_VALUE, MAX_VALUE));
   }
 
-  /**
-   * @skip
-   *
-   * Here for shared implementation with Arrays.hashCode
-   */
   public static int hashCode(byte b) {
     return b;
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Character.java b/user/super/com/google/gwt/emul/java/lang/Character.java
index 5ebeccc..ca0c93d 100644
--- a/user/super/com/google/gwt/emul/java/lang/Character.java
+++ b/user/super/com/google/gwt/emul/java/lang/Character.java
@@ -128,6 +128,7 @@
   public static final int MAX_CODE_POINT = 0x10FFFF;
 
   public static final int SIZE = 16;
+  public static final int BYTES = SIZE / Byte.SIZE;
 
   public static int charCount(int codePoint) {
     return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT ? 2 : 1;
@@ -217,11 +218,6 @@
     return forDigit(digit);
   }
 
-  /**
-   * @skip
-   *
-   * public for shared implementation with Arrays.hashCode
-   */
   public static int hashCode(char c) {
     return c;
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Double.java b/user/super/com/google/gwt/emul/java/lang/Double.java
index 390f694..27f1534 100644
--- a/user/super/com/google/gwt/emul/java/lang/Double.java
+++ b/user/super/com/google/gwt/emul/java/lang/Double.java
@@ -37,6 +37,7 @@
   public static final double NEGATIVE_INFINITY = -1d / 0d;
   public static final double POSITIVE_INFINITY = 1d / 0d;
   public static final int SIZE = 64;
+  public static final int BYTES = SIZE / Byte.SIZE;
   public static final Class<Double> TYPE = double.class;
 
   // 2^512, 2^-512
@@ -196,13 +197,14 @@
     return (ihi << 32) | ilo;
   }
 
-  /**
-   * @skip Here for shared implementation with Arrays.hashCode
-   */
   public static int hashCode(double d) {
     return (int) d;
   }
 
+  public static boolean isFinite(double x) {
+    return NEGATIVE_INFINITY < x && x < POSITIVE_INFINITY;
+  }
+
   public static boolean isInfinite(double x) {
     return x == POSITIVE_INFINITY || x == NEGATIVE_INFINITY;
   }
@@ -263,10 +265,22 @@
     return negative ? -d : d;
   }
 
+  public static double max(double a, double b) {
+    return Math.max(a, b);
+  }
+
+  public static double min(double a, double b) {
+    return Math.min(a, b);
+  }
+
   public static double parseDouble(String s) throws NumberFormatException {
     return __parseAndValidateDouble(s);
   }
 
+  public static double sum(double a, double b) {
+    return a + b;
+  }
+
   public static String toString(double b) {
     return String.valueOf(b);
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Float.java b/user/super/com/google/gwt/emul/java/lang/Float.java
index 5d3647b..565e2df 100644
--- a/user/super/com/google/gwt/emul/java/lang/Float.java
+++ b/user/super/com/google/gwt/emul/java/lang/Float.java
@@ -28,6 +28,7 @@
   public static final float NEGATIVE_INFINITY = -1f / 0f;
   public static final float POSITIVE_INFINITY = 1f / 0f;
   public static final int SIZE = 32;
+  public static final int BYTES = SIZE / Byte.SIZE;
   public static final Class<Float> TYPE = float.class;
 
   private static final long POWER_31_INT = 2147483648L;
@@ -85,7 +86,6 @@
   }
 
   /**
-   * @skip Here for shared implementation with Arrays.hashCode.
    * @param f
    * @return hash value of float (currently just truncated to int)
    */
@@ -130,6 +130,10 @@
     return (float) Double.longBitsToDouble(bits64);
   }
 
+  public static boolean isFinite(float x) {
+    return Double.isFinite(x);
+  }
+
   public static boolean isInfinite(float x) {
     return Double.isInfinite(x);
   }
@@ -138,6 +142,14 @@
     return Double.isNaN(x);
   }
 
+  public static float max(float a, float b) {
+    return Math.max(a, b);
+  }
+
+  public static float min(float a, float b) {
+    return Math.min(a, b);
+  }
+
   public static float parseFloat(String s) throws NumberFormatException {
     double doubleValue = __parseAndValidateDouble(s);
     if (doubleValue > Float.MAX_VALUE) {
@@ -148,6 +160,10 @@
     return (float) doubleValue;
   }
 
+  public static float sum(float a, float b) {
+    return a + b;
+  }
+
   public static String toString(float b) {
     return String.valueOf(b);
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Integer.java b/user/super/com/google/gwt/emul/java/lang/Integer.java
index 948bf75..bda0338 100644
--- a/user/super/com/google/gwt/emul/java/lang/Integer.java
+++ b/user/super/com/google/gwt/emul/java/lang/Integer.java
@@ -23,6 +23,7 @@
   public static final int MAX_VALUE = 0x7fffffff;
   public static final int MIN_VALUE = 0x80000000;
   public static final int SIZE = 32;
+  public static final int BYTES = SIZE / Byte.SIZE;
   public static final Class<Integer> TYPE = int.class;
 
   /**
@@ -71,11 +72,6 @@
     return Integer.valueOf(__decodeAndValidateInt(s, MIN_VALUE, MAX_VALUE));
   }
 
-  /**
-   * @skip
-   * 
-   * Here for shared implementation with Arrays.hashCode
-   */
   public static int hashCode(int i) {
     return i;
   }
@@ -98,6 +94,14 @@
     return i & -i;
   }
 
+  public static int max(int a, int b) {
+    return Math.max(a, b);
+  }
+
+  public static int min(int a, int b) {
+    return Math.min(a, b);
+  }
+
   public static int numberOfLeadingZeros(int i) {
     // Based on Henry S. Warren, Jr: "Hacker's Delight", p. 80.
     if (i < 0) {
@@ -197,6 +201,10 @@
     }
   }
 
+  public static int sum(int a, int b) {
+    return a + b;
+  }
+
   public static String toBinaryString(int value) {
     return toUnsignedRadixString(value, 2);
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Long.java b/user/super/com/google/gwt/emul/java/lang/Long.java
index 7115944..0654fa4 100644
--- a/user/super/com/google/gwt/emul/java/lang/Long.java
+++ b/user/super/com/google/gwt/emul/java/lang/Long.java
@@ -31,6 +31,7 @@
   public static final long MAX_VALUE = 0x7fffffffffffffffL;
   public static final long MIN_VALUE = 0x8000000000000000L;
   public static final int SIZE = 64;
+  public static final int BYTES = SIZE / Byte.SIZE;
   public static final Class<Long> TYPE = long.class;
 
   public static int bitCount(long i) {
@@ -54,9 +55,6 @@
     return valueOf(decode.payload, decode.radix);
   }
 
-  /**
-   * @skip Here for shared implementation with Arrays.hashCode
-   */
   public static int hashCode(long l) {
     return (int) l;
   }
@@ -74,6 +72,14 @@
     return i & -i;
   }
 
+  public static long max(long a, long b) {
+    return Math.max(a, b);
+  }
+
+  public static long min(long a, long b) {
+    return Math.min(a, b);
+  }
+
   public static int numberOfLeadingZeros(long i) {
     int high = (int) (i >> 32);
     if (high != 0) {
@@ -145,6 +151,10 @@
     }
   }
 
+  public static long sum(long a, long b) {
+    return a + b;
+  }
+
   public static String toBinaryString(long value) {
     return toPowerOfTwoUnsignedString(value, 1);
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Math.java b/user/super/com/google/gwt/emul/java/lang/Math.java
index fce3019..f996964 100644
--- a/user/super/com/google/gwt/emul/java/lang/Math.java
+++ b/user/super/com/google/gwt/emul/java/lang/Math.java
@@ -71,6 +71,20 @@
     return NativeMath.asin(x);
   }
 
+  public static int addExact(int x, int y) {
+    int r = x + y;
+    // "Hacker's Delight" 2-12 Overflow if both arguments have the opposite sign of the result
+    throwOverflowIf(((x ^ r) & (y ^ r)) < 0);
+    return r;
+  }
+
+  public static long addExact(long x, long y) {
+    long r = x + y;
+    // "Hacker's Delight" 2-12 Overflow if both arguments have the opposite sign of the result
+    throwOverflowIf(((x ^ r) & (y ^ r)) < 0);
+    return r;
+  }
+
   public static double atan(double x) {
     return NativeMath.atan(x);
   }
@@ -107,6 +121,16 @@
     return (Math.exp(x) + Math.exp(-x)) / 2.0;
   }
 
+  public static int decrementExact(int x) {
+    throwOverflowIf(x == Integer.MIN_VALUE);
+    return x - 1;
+  }
+
+  public static long decrementExact(long x) {
+    throwOverflowIf(x == Long.MIN_VALUE);
+    return x - 1;
+  }
+
   public static double exp(double x) {
     return NativeMath.exp(x);
   }
@@ -128,10 +152,48 @@
     return NativeMath.floor(x);
   }
 
+  public static int floorDiv(int dividend, int divisor) {
+    throwDivByZeroIf(divisor == 0);
+    int r = dividend / divisor;
+    // if the signs are different and modulo not zero, round down
+    if ((dividend ^ divisor) < 0 && (r * divisor != dividend)) {
+      r--;
+    }
+    return r;
+  }
+
+  public static long floorDiv(long dividend, long divisor) {
+    throwDivByZeroIf(divisor == 0);
+    long r = dividend / divisor;
+    // if the signs are different and modulo not zero, round down
+    if ((dividend ^ divisor) < 0 && (r * divisor != dividend)) {
+      r--;
+    }
+    return r;
+  }
+
+  public static int floorMod(int dividend, int divisor) {
+    return dividend - floorDiv(dividend, divisor) * divisor;
+  }
+
+  public static long floorMod(long dividend, long divisor) {
+    return dividend - floorDiv(dividend, divisor) * divisor;
+  }
+
   public static double hypot(double x, double y) {
     return sqrt(x * x + y * y);
   }
 
+  public static int incrementExact(int x) {
+    throwOverflowIf(x == Integer.MAX_VALUE);
+    return x + 1;
+  }
+
+  public static long incrementExact(long x) {
+    throwOverflowIf(x == Long.MAX_VALUE);
+    return x + 1;
+  }
+
   public static double log(double x) {
     return NativeMath.log(x);
   }
@@ -176,6 +238,29 @@
     return x < y ? x : y;
   }
 
+  public static int multiplyExact(int x, int y) {
+    long r = (long) x * (long) y;
+    int ir = (int) r;
+    throwOverflowIf(ir != r);
+    return ir;
+  }
+
+  public static long multiplyExact(long x, long y) {
+    long r = x * y;
+    throwOverflowIf((x == Long.MIN_VALUE && y == -1) || (y != 0 && (r / y != x)));
+    return r;
+  }
+
+  public static int negateExact(int x) {
+    throwOverflowIf(x == Integer.MIN_VALUE);
+    return -x;
+  }
+
+  public static long negateExact(long x) {
+    throwOverflowIf(x == Long.MIN_VALUE);
+    return -x;
+  }
+
   public static double pow(double x, double exp) {
     return NativeMath.pow(x, exp);
   }
@@ -209,6 +294,22 @@
     return d;
   }-*/;
 
+  public static int subtractExact(int x, int y) {
+    int r = x - y;
+    // "Hacker's Delight" Overflow if the arguments have different signs and
+    // the sign of the result is different than the sign of x
+    throwOverflowIf(((x ^ y) & (x ^ r)) < 0);
+    return r;
+  }
+
+  public static long subtractExact(long x, long y) {
+    long r = x - y;
+    // "Hacker's Delight" Overflow if the arguments have different signs and
+    // the sign of the result is different than the sign of x
+    throwOverflowIf(((x ^ y) & (x ^ r)) < 0);
+    return r;
+  }
+
   public static double scalb(double d, int scaleFactor) {
     if (scaleFactor >= 31 || scaleFactor <= -31) {
       return d * Math.pow(2, scaleFactor);
@@ -268,10 +369,28 @@
     return x * PI_UNDER_180;
   }
 
+  public static int toIntExact(long x) {
+    int ix = (int) x;
+    throwOverflowIf(ix != x);
+    return ix;
+  }
+
   public static double toRadians(double x) {
     return x * PI_OVER_180;
   }
 
+  private static void throwDivByZeroIf(boolean condition) {
+    if (condition) {
+      throw new ArithmeticException("div by zero");
+    }
+  }
+
+  private static void throwOverflowIf(boolean condition) {
+    if (condition) {
+      throw new ArithmeticException("overflow");
+    }
+  }
+
   @JsType(isNative = true, name = "Math", namespace = JsPackage.GLOBAL)
   private static class NativeMath {
     public static double LOG10E;
diff --git a/user/super/com/google/gwt/emul/java/lang/Runnable.java b/user/super/com/google/gwt/emul/java/lang/Runnable.java
index 31e49e5..4a51e4b 100644
--- a/user/super/com/google/gwt/emul/java/lang/Runnable.java
+++ b/user/super/com/google/gwt/emul/java/lang/Runnable.java
@@ -16,15 +16,16 @@
 package java.lang;
 
 /**
- * Encapsulates an action for later execution. <a
- * href="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Runnable.html">[Sun
- * docs]</a>
- * 
+ * Encapsulates an action for later execution.
+ * See <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html">
+ * the official Java API doc</a> for details.
+ *
  * <p>
  * This interface is provided only for JRE compatibility. GWT does not support
  * multithreading.
  * </p>
  */
+@FunctionalInterface
 public interface Runnable {
   void run();
 }
diff --git a/user/super/com/google/gwt/emul/java/lang/Short.java b/user/super/com/google/gwt/emul/java/lang/Short.java
index 6b03f9c..c42d03c 100644
--- a/user/super/com/google/gwt/emul/java/lang/Short.java
+++ b/user/super/com/google/gwt/emul/java/lang/Short.java
@@ -23,6 +23,7 @@
   public static final short MIN_VALUE = (short) 0x8000;
   public static final short MAX_VALUE = (short) 0x7fff;
   public static final int SIZE = 16;
+  public static final int BYTES = SIZE / Byte.SIZE;
   public static final Class<Short> TYPE = short.class;
 
   /**
@@ -41,9 +42,6 @@
     return Short.valueOf((short) __decodeAndValidateInt(s, MIN_VALUE, MAX_VALUE));
   }
 
-  /**
-   * @skip Here for shared implementation with Arrays.hashCode
-   */
   public static int hashCode(short s) {
     return s;
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/String.java b/user/super/com/google/gwt/emul/java/lang/String.java
index 2a31e81..5e106c2 100644
--- a/user/super/com/google/gwt/emul/java/lang/String.java
+++ b/user/super/com/google/gwt/emul/java/lang/String.java
@@ -16,6 +16,7 @@
 
 package java.lang;
 
+import static javaemul.internal.InternalPreconditions.checkNotNull;
 import static javaemul.internal.InternalPreconditions.checkStringBounds;
 
 import java.io.Serializable;
@@ -24,6 +25,7 @@
 import java.nio.charset.UnsupportedCharsetException;
 import java.util.Comparator;
 import java.util.Locale;
+import java.util.StringJoiner;
 
 import javaemul.internal.ArrayHelper;
 import javaemul.internal.EmulatedCharset;
@@ -110,6 +112,26 @@
     return valueOf(v, offset, count);
   }
 
+  public static String join(CharSequence delimiter, CharSequence... elements) {
+    checkNotNull(delimiter, "delimiter");
+    checkNotNull(elements, "elements");
+    StringJoiner joiner = new StringJoiner(delimiter);
+    for (CharSequence e : elements) {
+      joiner.add(e);
+    }
+    return joiner.toString();
+  }
+
+  public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {
+    checkNotNull(delimiter, "delimiter");
+    checkNotNull(elements, "elements");
+    StringJoiner joiner = new StringJoiner(delimiter);
+    for (CharSequence e : elements) {
+      joiner.add(e);
+    }
+    return joiner.toString();
+  }
+
   public static String valueOf(boolean x) {
     return "" + x;
   }
diff --git a/user/super/com/google/gwt/emul/java/math/BigInteger.java b/user/super/com/google/gwt/emul/java/math/BigInteger.java
index 545b861..840cb3c 100644
--- a/user/super/com/google/gwt/emul/java/math/BigInteger.java
+++ b/user/super/com/google/gwt/emul/java/math/BigInteger.java
@@ -615,7 +615,7 @@
    *         does not fit in a {@code byte}.
    */
   public byte byteValueExact() {
-    if (numberLength <= 1 && bitLength() <= 7) {
+    if (numberLength <= 1 && bitLength() < Byte.SIZE) {
       return byteValue();
     }
     throw new ArithmeticException("out of byte range");
@@ -923,7 +923,7 @@
    *         does not fit in an {@code int}.
    */
   public int intValueExact() {
-    if (numberLength <= 1 && bitLength() <= 31) {
+    if (numberLength <= 1 && bitLength() < Integer.SIZE) {
       return intValue();
     }
     throw new ArithmeticException("out of int range");
@@ -965,7 +965,7 @@
    *         does not fit in a {@code long}.
    */
   public long longValueExact() {
-    if (numberLength <= 2 && bitLength() <= 63) {
+    if (numberLength <= 2 && bitLength() < Long.SIZE) {
       return longValue();
     }
     throw new ArithmeticException("out of long range");
@@ -1304,7 +1304,7 @@
    *         does not fit in a {@code short}.
    */
   public short shortValueExact() {
-    if (numberLength <= 1 && bitLength() <= 15) {
+    if (numberLength <= 1 && bitLength() < Short.SIZE) {
       return shortValue();
     }
     throw new ArithmeticException("out of short range");
diff --git a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
index 7fb15e5..8d84e2d 100644
--- a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
@@ -164,6 +164,38 @@
     assertFalse(Double.isInfinite(Double.NaN));
   }
 
+  public void testIsFinite() {
+    final double[] nonfiniteNumbers = {
+        Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN,
+    };
+    for (double value : nonfiniteNumbers) {
+      assertFalse(Double.isFinite(value));
+    }
+
+    final double[] finiteNumbers = {
+        -Double.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE,
+        -1.0, -0.5, -0.1, -0.0, 0.0, 0.1, 0.5, 1.0,
+    };
+    for (double value : finiteNumbers) {
+      assertTrue(Double.isFinite(value));
+    }
+  }
+
+  public void testIsInfinite() {
+    assertTrue(Double.isInfinite(Double.NEGATIVE_INFINITY));
+    assertTrue(Double.isInfinite(Double.POSITIVE_INFINITY));
+
+    assertFalse(Double.isInfinite(Double.NaN));
+
+    final double[] finiteNumbers = {
+        -Double.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE,
+        -1.0, -0.5, -0.1, -0.0, 0.0, 0.1, 0.5, 1.0,
+    };
+    for (double value : finiteNumbers) {
+      assertFalse(Double.isInfinite(value));
+    }
+  }
+
   public void testParse() {
     assertTrue(0 == Double.parseDouble("0"));
     assertTrue(100 == Double.parseDouble("1e2"));
diff --git a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
index f12efcd..87dc276 100644
--- a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
@@ -97,6 +97,38 @@
     assertFalse(Float.isInfinite(Float.NaN));
   }
 
+  public void testIsFinite() {
+    final float[] nonfiniteNumbers = {
+        Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, Float.NaN,
+    };
+    for (float value : nonfiniteNumbers) {
+      assertFalse(Float.isFinite(value));
+    }
+
+    final float[] finiteNumbers = {
+        -Float.MAX_VALUE, Float.MAX_VALUE, Float.MIN_VALUE,
+        -1.0f, -0.5f, -0.1f, -0.0f, 0.0f, 0.1f, 0.5f, 1.0f,
+    };
+    for (float value : finiteNumbers) {
+      assertTrue(Float.isFinite(value));
+    }
+  }
+
+  public void testIsInfinite() {
+    assertTrue(Float.isInfinite(Float.NEGATIVE_INFINITY));
+    assertTrue(Float.isInfinite(Float.POSITIVE_INFINITY));
+
+    assertFalse(Float.isInfinite(Float.NaN));
+
+    final float[] finiteNumbers = {
+        -Float.MAX_VALUE, Float.MAX_VALUE, Float.MIN_VALUE,
+        -1.0f, -0.5f, -0.1f, -0.0f, 0.0f, 0.1f, 0.5f, 1.0f,
+    };
+    for (float value : finiteNumbers) {
+      assertFalse(Float.isInfinite(value));
+    }
+  }
+
   public void testParse() {
     /*
      * Note: we must use appropriate deltas for a somewhat subtle reason.
diff --git a/user/test/com/google/gwt/emultest/java/lang/MathTest.java b/user/test/com/google/gwt/emultest/java/lang/MathTest.java
index 55d295a..9b8bb5d 100644
--- a/user/test/com/google/gwt/emultest/java/lang/MathTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/MathTest.java
@@ -18,6 +18,9 @@
 
 import com.google.gwt.junit.client.GWTTestCase;
 
+import java.math.BigInteger;
+import java.util.ArrayList;
+
 /**
  * Tests for JRE emulation of java.lang.Math.
  *
@@ -25,6 +28,9 @@
  */
 public class MathTest extends GWTTestCase {
 
+  private static final Integer[] ALL_INTEGER_CANDIDATES = getAllIntegerCandidates();
+  private static final Long[] ALL_LONG_CANDIDATES = getAllLongCandidates();
+
   private static boolean isNegativeZero(double x) {
     return Double.doubleToLongBits(-0.0) == Double.doubleToLongBits(x);
   }
@@ -58,6 +64,36 @@
     assertTrue(Double.isNaN(v));
   }
 
+  public void testAddExact() {
+    for (int a : ALL_INTEGER_CANDIDATES) {
+      for (int b : ALL_INTEGER_CANDIDATES) {
+        BigInteger expectedResult = BigInteger.valueOf(a).add(BigInteger.valueOf(b));
+        boolean expectedSuccess = fitsInInt(expectedResult);
+        try {
+          assertEquals(a + b, Math.addExact(a, b));
+          assertTrue(expectedSuccess);
+        } catch (ArithmeticException e) {
+          assertFalse(expectedSuccess);
+        }
+      }
+    }
+  }
+
+  public void testAddExactLongs() {
+    for (long a : ALL_LONG_CANDIDATES) {
+      for (long b : ALL_LONG_CANDIDATES) {
+        BigInteger expectedResult = BigInteger.valueOf(a).add(BigInteger.valueOf(b));
+        boolean expectedSuccess = fitsInLong(expectedResult);
+        try {
+          assertEquals(a + b, Math.addExact(a, b));
+          assertTrue(expectedSuccess);
+        } catch (ArithmeticException e) {
+          assertFalse(expectedSuccess);
+        }
+      }
+    }
+  }
+
   public void testCbrt() {
     double v = Math.cbrt(1000.0);
     assertEquals(10.0, v, 1e-7);
@@ -97,6 +133,120 @@
     assertEquals(Double.POSITIVE_INFINITY, v);
   }
 
+  public void testDecrementExact() {
+    for (int a : ALL_INTEGER_CANDIDATES) {
+      BigInteger expectedResult = BigInteger.valueOf(a).subtract(BigInteger.ONE);
+      boolean expectedSuccess = fitsInInt(expectedResult);
+      try {
+        assertEquals(a - 1, Math.decrementExact(a));
+        assertTrue(expectedSuccess);
+      } catch (ArithmeticException e) {
+        assertFalse(expectedSuccess);
+      }
+    }
+  }
+
+  public void testDecrementExactLong() {
+    for (long a : ALL_LONG_CANDIDATES) {
+      BigInteger expectedResult = BigInteger.valueOf(a).subtract(BigInteger.ONE);
+      boolean expectedSuccess = fitsInLong(expectedResult);
+      try {
+        assertEquals(a - 1, Math.decrementExact(a));
+        assertTrue(expectedSuccess);
+      } catch (ArithmeticException e) {
+        assertFalse(expectedSuccess);
+      }
+    }
+  }
+
+  public void testFloorDiv() {
+    assertEquals(0, Math.floorDiv(0, 1));
+    assertEquals(1, Math.floorDiv(4, 3));
+    assertEquals(-2, Math.floorDiv(4, -3));
+    assertEquals(-2, Math.floorDiv(-4, 3));
+    assertEquals(1, Math.floorDiv(-4, -3));
+
+    // special case
+    assertEquals(Integer.MIN_VALUE, Math.floorDiv(Integer.MIN_VALUE, -1));
+
+    try {
+      Math.floorDiv(1, 0);
+      fail();
+    } catch (ArithmeticException expected) {
+    }
+  }
+
+  public void testFloorDivLongs() {
+    assertEquals(0L, Math.floorDiv(0L, 1L));
+    assertEquals(1L, Math.floorDiv(4L, 3L));
+    assertEquals(-2L, Math.floorDiv(4L, -3L));
+    assertEquals(-2L, Math.floorDiv(-4L, 3L));
+    assertEquals(1L, Math.floorDiv(-4L, -3L));
+
+    // special case
+    assertEquals(Long.MIN_VALUE, Math.floorDiv(Long.MIN_VALUE, -1));
+
+    try {
+      Math.floorDiv(1L, 0L);
+      fail();
+    } catch (ArithmeticException expected) {
+    }
+  }
+
+  public void testFloorMod() {
+    assertEquals(0, Math.floorMod(0, 1));
+    assertEquals(1, Math.floorMod(4, 3));
+    assertEquals(-2, Math.floorMod(4, -3));
+    assertEquals(2, Math.floorMod(-4, 3));
+    assertEquals(-1, Math.floorMod(-4, -3));
+
+    try {
+      Math.floorMod(1, 0);
+      fail();
+    } catch (ArithmeticException expected) {
+    }
+  }
+
+  public void testFloorModLongs() {
+    assertEquals(0L, Math.floorMod(0L, 1L));
+    assertEquals(1L, Math.floorMod(4L, 3L));
+    assertEquals(-2L, Math.floorMod(4L, -3L));
+    assertEquals(2L, Math.floorMod(-4L, 3L));
+    assertEquals(-1L, Math.floorMod(-4L, -3L));
+
+    try {
+      Math.floorMod(1L, 0L);
+      fail();
+    } catch (ArithmeticException expected) {
+    }
+  }
+
+  public void testIncrementExact() {
+    for (int a : ALL_INTEGER_CANDIDATES) {
+      BigInteger expectedResult = BigInteger.valueOf(a).add(BigInteger.ONE);
+      boolean expectedSuccess = fitsInInt(expectedResult);
+      try {
+        assertEquals(a + 1, Math.incrementExact(a));
+        assertTrue(expectedSuccess);
+      } catch (ArithmeticException e) {
+        assertFalse(expectedSuccess);
+      }
+    }
+  }
+
+  public void testIncrementExactLong() {
+    for (long a : ALL_LONG_CANDIDATES) {
+      BigInteger expectedResult = BigInteger.valueOf(a).add(BigInteger.ONE);
+      boolean expectedSuccess = fitsInLong(expectedResult);
+      try {
+        assertEquals(a + 1, Math.incrementExact(a));
+        assertTrue(expectedSuccess);
+      } catch (ArithmeticException e) {
+        assertFalse(expectedSuccess);
+      }
+    }
+  }
+
   public void testMax() {
     assertEquals(2d, Math.max(1d, 2d));
     assertEquals(2d, Math.max(2d, 1d));
@@ -171,6 +321,62 @@
     assertEquals(3.0, v, 1e-15);
   }
 
+  public void testMultiplyExact() {
+    for (int a : ALL_INTEGER_CANDIDATES) {
+      for (int b : ALL_INTEGER_CANDIDATES) {
+        BigInteger expectedResult = BigInteger.valueOf(a).multiply(BigInteger.valueOf(b));
+        boolean expectedSuccess = fitsInInt(expectedResult);
+        try {
+          assertEquals(a * b, Math.multiplyExact(a, b));
+          assertTrue(expectedSuccess);
+        } catch (ArithmeticException e) {
+          assertFalse(expectedSuccess);
+        }
+      }
+    }
+  }
+
+  public void testMultiplyExactLongs() {
+    for (long a : ALL_LONG_CANDIDATES) {
+      for (long b : ALL_LONG_CANDIDATES) {
+        BigInteger expectedResult = BigInteger.valueOf(a).multiply(BigInteger.valueOf(b));
+        boolean expectedSuccess = fitsInLong(expectedResult);
+        try {
+          assertEquals(a * b, Math.multiplyExact(a, b));
+          assertTrue(expectedSuccess);
+        } catch (ArithmeticException e) {
+          assertFalse(expectedSuccess);
+        }
+      }
+    }
+  }
+
+  public void testNegateExact() {
+    for (int a : ALL_INTEGER_CANDIDATES) {
+      BigInteger expectedResult = BigInteger.valueOf(a).negate();
+      boolean expectedSuccess = fitsInInt(expectedResult);
+      try {
+        assertEquals(-a, Math.negateExact(a));
+        assertTrue(expectedSuccess);
+      } catch (ArithmeticException e) {
+        assertFalse(expectedSuccess);
+      }
+    }
+  }
+
+  public void testNegateExactLong() {
+    for (long a : ALL_LONG_CANDIDATES) {
+      BigInteger expectedResult = BigInteger.valueOf(a).negate();
+      boolean expectedSuccess = fitsInLong(expectedResult);
+      try {
+        assertEquals(-a, Math.negateExact(a));
+        assertTrue(expectedSuccess);
+      } catch (ArithmeticException e) {
+        assertFalse(expectedSuccess);
+      }
+    }
+  }
+
   public void testSin() {
     double v = Math.sin(0.0);
     assertEquals(0.0, v, 1e-7);
@@ -254,4 +460,97 @@
     assertEquals(4294967296.0f, Math.scalb(1f, 32));
     assertEquals(2.3283064e-10f, Math.scalb(1f, -32), 1e-7f);
   }
+
+  public void testSubtractExact() {
+    for (int a : ALL_INTEGER_CANDIDATES) {
+      for (int b : ALL_INTEGER_CANDIDATES) {
+        BigInteger expectedResult = BigInteger.valueOf(a).subtract(BigInteger.valueOf(b));
+        boolean expectedSuccess = fitsInInt(expectedResult);
+        try {
+          assertEquals(a - b, Math.subtractExact(a, b));
+          assertTrue(expectedSuccess);
+        } catch (ArithmeticException e) {
+          assertFalse(expectedSuccess);
+        }
+      }
+    }
+  }
+
+  public void testSubtractExactLongs() {
+    for (long a : ALL_LONG_CANDIDATES) {
+      for (long b : ALL_LONG_CANDIDATES) {
+        BigInteger expectedResult = BigInteger.valueOf(a).subtract(BigInteger.valueOf(b));
+        boolean expectedSuccess = fitsInLong(expectedResult);
+        try {
+          assertEquals(a - b, Math.subtractExact(a, b));
+          assertTrue(expectedSuccess);
+        } catch (ArithmeticException e) {
+          assertFalse(expectedSuccess);
+        }
+      }
+    }
+  }
+
+  public void testToIntExact() {
+    final long[] longs = {0, -1, 1, Integer.MIN_VALUE, Integer.MAX_VALUE,
+        Integer.MIN_VALUE - 1L, Integer.MAX_VALUE + 1L, Long.MIN_VALUE, Long.MAX_VALUE};
+    for (long a : longs) {
+      boolean expectedSuccess = (int) a == a;
+      try {
+        assertEquals((int) a, Math.toIntExact(a));
+        assertTrue(expectedSuccess);
+      } catch (ArithmeticException e) {
+        assertFalse(expectedSuccess);
+      }
+    }
+  }
+
+  private static boolean fitsInInt(BigInteger big) {
+    return big.bitLength() < Integer.SIZE;
+  }
+
+  private static boolean fitsInLong(BigInteger big) {
+    return big.bitLength() < Long.SIZE;
+  }
+
+  private static Integer[] getAllIntegerCandidates() {
+    ArrayList<Integer> candidates = new ArrayList<Integer>();
+    candidates.add(0);
+    candidates.add(-1);
+    candidates.add(1);
+    candidates.add(Integer.MAX_VALUE / 2);
+    candidates.add(Integer.MAX_VALUE / 2 - 1);
+    candidates.add(Integer.MAX_VALUE / 2 + 1);
+    candidates.add(Integer.MIN_VALUE / 2);
+    candidates.add(Integer.MIN_VALUE / 2 - 1);
+    candidates.add(Integer.MIN_VALUE / 2 + 1);
+    candidates.add(Integer.MAX_VALUE - 1);
+    candidates.add(Integer.MAX_VALUE);
+    candidates.add(Integer.MIN_VALUE + 1);
+    candidates.add(Integer.MIN_VALUE);
+    return candidates.toArray(new Integer[candidates.size()]);
+  }
+
+  private static Long[] getAllLongCandidates() {
+    ArrayList<Long> candidates = new ArrayList<Long>();
+
+    for (Integer x : getAllIntegerCandidates()) {
+      candidates.add(x.longValue());
+    }
+
+    candidates.add(Long.MAX_VALUE / 2);
+    candidates.add(Long.MAX_VALUE / 2 - 1);
+    candidates.add(Long.MAX_VALUE / 2 + 1);
+    candidates.add(Long.MIN_VALUE / 2);
+    candidates.add(Long.MIN_VALUE / 2 - 1);
+    candidates.add(Long.MIN_VALUE / 2 + 1);
+    candidates.add(Integer.MAX_VALUE + 1L);
+    candidates.add(Long.MAX_VALUE - 1L);
+    candidates.add(Long.MAX_VALUE);
+    candidates.add(Integer.MIN_VALUE - 1L);
+    candidates.add(Long.MIN_VALUE + 1L);
+    candidates.add(Long.MIN_VALUE);
+
+    return candidates.toArray(new Long[candidates.size()]);
+  }
 }
diff --git a/user/test/com/google/gwt/emultest/java/lang/StringTest.java b/user/test/com/google/gwt/emultest/java/lang/StringTest.java
index b9f06aa..e897f9d 100644
--- a/user/test/com/google/gwt/emultest/java/lang/StringTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/StringTest.java
@@ -20,6 +20,7 @@
 
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;
+import java.util.Arrays;
 import java.util.Locale;
 
 /**
@@ -460,6 +461,24 @@
     assertSame("interns are not the same reference", s1.intern(), s2.intern());
   }
 
+  public void testJoin() {
+    assertEquals("", String.join("", ""));
+    assertEquals("", String.join(",", ""));
+    assertEquals("", String.join(",", Arrays.<String>asList()));
+
+    assertEquals("a", String.join("", "a"));
+    assertEquals("a", String.join(",", "a"));
+    assertEquals("a", String.join(",", Arrays.asList("a")));
+
+    assertEquals("ab", String.join("", "a", "b"));
+    assertEquals("a,b", String.join(",", "a", "b"));
+    assertEquals("a,b", String.join(",", Arrays.asList("a", "b")));
+
+    assertEquals("abc", String.join("", "a", "b", "c"));
+    assertEquals("a,b,c", String.join(",", "a", "b", "c"));
+    assertEquals("a,b,c", String.join(",", Arrays.asList("a", "b", "c")));
+  }
+
   public void testLastIndexOf() {
     String x = "abcdeabcdef";
     assertEquals(9, x.lastIndexOf("e"));