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 600c873..545b861 100644
--- a/user/super/com/google/gwt/emul/java/math/BigInteger.java
+++ b/user/super/com/google/gwt/emul/java/math/BigInteger.java
@@ -607,6 +607,21 @@
   }
 
   /**
+   * Converts value of this {@code BigInteger} to a {@code byte} if it fits it,
+   * otherwise {@code ArithmeticException} is thrown.
+   *
+   * @return this {@code BigInteger} converted to a {@code byte}.
+   * @throws ArithmeticException if the value of this {@code BigInteger}
+   *         does not fit in a {@code byte}.
+   */
+  public byte byteValueExact() {
+    if (numberLength <= 1 && bitLength() <= 7) {
+      return byteValue();
+    }
+    throw new ArithmeticException("out of byte range");
+  }
+
+  /**
    * Returns a new {@code BigInteger} which has the same binary representation
    * as {@code this} but with the bit at position n cleared. The result is
    * equivalent to {@code this & ~(2^n)}.
@@ -900,6 +915,21 @@
   }
 
   /**
+   * Converts value of this {@code BigInteger} to an {@code int} if it fits it,
+   * otherwise {@code ArithmeticException} is thrown.
+   *
+   * @return this {@code BigInteger} converted to an {@code int}.
+   * @throws ArithmeticException if the value of this {@code BigInteger}
+   *         does not fit in an {@code int}.
+   */
+  public int intValueExact() {
+    if (numberLength <= 1 && bitLength() <= 31) {
+      return intValue();
+    }
+    throw new ArithmeticException("out of int range");
+  }
+
+  /**
    * Tests whether this {@code BigInteger} is probably prime. If {@code true} is
    * returned, then this is prime with a probability beyond (1-1/2^certainty).
    * If {@code false} is returned, then this is definitely composite. If the
@@ -927,6 +957,21 @@
   }
 
   /**
+   * Converts value of this {@code BigInteger} to a {@code long} if it fits it,
+   * otherwise {@code ArithmeticException} is thrown.
+   *
+   * @return this {@code BigInteger} converted to a {@code long}.
+   * @throws ArithmeticException if the value of this {@code BigInteger}
+   *         does not fit in a {@code long}.
+   */
+  public long longValueExact() {
+    if (numberLength <= 2 && bitLength() <= 63) {
+      return longValue();
+    }
+    throw new ArithmeticException("out of long range");
+  }
+
+  /**
    * Returns the maximum of this {@code BigInteger} and {@code val}.
    *
    * @param val value to be used to compute the maximum with {@code this}
@@ -1251,6 +1296,21 @@
   }
 
   /**
+   * Converts value of this {@code BigInteger} to a {@code short} if it fits it,
+   * otherwise {@code ArithmeticException} is thrown.
+   *
+   * @return this {@code BigInteger} converted to a {@code short}.
+   * @throws ArithmeticException if the value of this {@code BigInteger}
+   *         does not fit in a {@code short}.
+   */
+  public short shortValueExact() {
+    if (numberLength <= 1 && bitLength() <= 15) {
+      return shortValue();
+    }
+    throw new ArithmeticException("out of short range");
+  }
+
+  /**
    * Returns the sign of this {@code BigInteger}.
    *
    * @return {@code -1} if {@code this < 0}, {@code 0} if {@code this == 0},
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerConvertTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerConvertTest.java
index 2ca911c..e21ac63 100644
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerConvertTest.java
+++ b/user/test/com/google/gwt/emultest/java/math/BigIntegerConvertTest.java
@@ -46,6 +46,26 @@
  * valueOf(long val), floatValue(), doubleValue().
  */
 public class BigIntegerConvertTest extends EmulTestBase {
+
+  public void testByteValueExact() {
+    assertEquals(-1, BigInteger.valueOf(-1).byteValueExact());
+    assertEquals(0, BigInteger.valueOf(0).byteValueExact());
+    assertEquals(1, BigInteger.valueOf(1).byteValueExact());
+    assertEquals(Byte.MAX_VALUE, BigInteger.valueOf(Byte.MAX_VALUE).byteValueExact());
+    assertEquals(Byte.MIN_VALUE, BigInteger.valueOf(Byte.MIN_VALUE).byteValueExact());
+
+    try {
+      BigInteger.valueOf(Byte.MAX_VALUE + 1).byteValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+    try {
+      BigInteger.valueOf(Byte.MIN_VALUE - 1).byteValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+  }
+
   /**
    * Convert a negative number to a double value. The number's bit length is
    * less than 64 bits.
@@ -634,6 +654,25 @@
     assertEquals(resInt, aNumber);
   }
 
+  public void testIntValueExact() {
+    assertEquals(-1, BigInteger.valueOf(-1).intValueExact());
+    assertEquals(0, BigInteger.valueOf(0).intValueExact());
+    assertEquals(1, BigInteger.valueOf(1).intValueExact());
+    assertEquals(Integer.MAX_VALUE, BigInteger.valueOf(Integer.MAX_VALUE).intValueExact());
+    assertEquals(Integer.MIN_VALUE, BigInteger.valueOf(Integer.MIN_VALUE).intValueExact());
+
+    try {
+      BigInteger.valueOf(Integer.MAX_VALUE + 1L).intValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+    try {
+      BigInteger.valueOf(Integer.MIN_VALUE - 1L).intValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+  }
+
   /**
    * Convert a number to a negative long value The BigInteger is longer than
    * int.
@@ -676,6 +715,44 @@
     assertEquals(result, aNumber);
   }
 
+  public void testLongValueExact() {
+    assertEquals(-1, BigInteger.valueOf(-1).longValueExact());
+    assertEquals(0, BigInteger.valueOf(0).longValueExact());
+    assertEquals(1, BigInteger.valueOf(1).longValueExact());
+    assertEquals(Long.MAX_VALUE, BigInteger.valueOf(Long.MAX_VALUE).longValueExact());
+    assertEquals(Long.MIN_VALUE, BigInteger.valueOf(Long.MIN_VALUE).longValueExact());
+
+    try {
+      BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE).longValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+    try {
+      BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE).longValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+  }
+
+  public void testShortValueExact() {
+    assertEquals(-1, BigInteger.valueOf(-1).shortValueExact());
+    assertEquals(0, BigInteger.valueOf(0).shortValueExact());
+    assertEquals(1, BigInteger.valueOf(1).shortValueExact());
+    assertEquals(Short.MAX_VALUE, BigInteger.valueOf(Short.MAX_VALUE).shortValueExact());
+    assertEquals(Short.MIN_VALUE, BigInteger.valueOf(Short.MIN_VALUE).shortValueExact());
+
+    try {
+      BigInteger.valueOf(Short.MAX_VALUE + 1).shortValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+    try {
+      BigInteger.valueOf(Short.MIN_VALUE - 1).shortValueExact();
+      fail("overflow expected");
+    } catch (Exception expected) {
+    }
+  }
+
   /**
    * valueOf (long val): convert Integer.MAX_VALUE to a BigInteger.
    */