diff --git a/user/super/com/google/gwt/emul/java/math/BigDecimal.java b/user/super/com/google/gwt/emul/java/math/BigDecimal.java
index 0802895..9f310cd 100644
--- a/user/super/com/google/gwt/emul/java/math/BigDecimal.java
+++ b/user/super/com/google/gwt/emul/java/math/BigDecimal.java
@@ -2572,7 +2572,7 @@
 
   private BigInteger getUnscaledValue() {
     if (intVal == null) {
-      intVal = BigInteger.valueOf(smallValue);
+      intVal = BigInteger.valueOf((long) smallValue);
     }
     return intVal;
   }
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 4f27600..8fe9f77 100644
--- a/user/super/com/google/gwt/emul/java/math/BigInteger.java
+++ b/user/super/com/google/gwt/emul/java/math/BigInteger.java
@@ -34,6 +34,7 @@
  */
 package java.math;
 
+import static javaemul.internal.Coercions.ensureInt;
 import static javaemul.internal.InternalPreconditions.checkCriticalArgument;
 import static javaemul.internal.InternalPreconditions.checkNotNull;
 
@@ -96,11 +97,6 @@
   static final BigInteger MINUS_ONE = new BigInteger(-1, 1);
 
   /**
-   * 2^32.
-   */
-  static final double POW32 = 4294967296d;
-
-  /**
    * All the {@code BigInteger} numbers in the range [0,10] are cached.
    */
   static final BigInteger[] SMALL_VALUES = {
@@ -139,17 +135,19 @@
   }
 
   public static BigInteger valueOf(long val) {
-    if (val < 0) {
-      if (val != -1) {
-        return new BigInteger(-1, -val);
-      }
-      return MINUS_ONE;
-    } else if (val <= 10) {
-      return SMALL_VALUES[(int) val];
-    } else {
-      // (val > 10)
-      return new BigInteger(1, val);
+    return val >= 0 ? BigInteger.fromBits(val) : BigInteger.fromBits(-val).negate();
+  }
+
+  private static BigInteger fromBits(long bits) {
+    int lowBits = (int) bits;
+    int highBits = LongUtils.getHighBits(bits);
+    if (highBits != 0) {
+      return new BigInteger(1, lowBits, highBits);
     }
+    if (lowBits > 10 || lowBits < 0) {
+      return new BigInteger(1, lowBits);
+    }
+    return SMALL_VALUES[lowBits];
   }
 
   static BigInteger getPowerOfTwo(int exp) {
@@ -163,20 +161,6 @@
     return new BigInteger(1, intCount + 1, resDigits);
   }
 
-  public static BigInteger valueOf(double val) {
-    if (val < 0) {
-      if (val != -1) {
-        return new BigInteger(-1, -val);
-      }
-      return MINUS_ONE;
-    } else if (val <= 10) {
-      return SMALL_VALUES[(int) val];
-    } else {
-      // (val > 10)
-      return new BigInteger(1, val);
-    }
-  }
-
   /**
    * @see BigInteger#BigInteger(String, int)
    */
@@ -235,18 +219,6 @@
   }
 
   /**
-   * Converts an integral double to an unsigned integer; ie 2^31 will be
-   * returned as 0x80000000.
-   *
-   * @param val
-   * @return val as an unsigned int
-   */
-  @SuppressWarnings("unusable-by-js")
-  private static native int toUnsignedInt(double val) /*-{
-    return val | 0;
-  }-*/;
-
-  /**
    * The magnitude of this big integer. This array is in little endian order and
    * each "digit" is a 32-bit unsigned integer. For example: {@code 13} is
    * represented as [ 13 ] {@code -13} is represented as [ 13 ] {@code 2^32 +
@@ -438,16 +410,17 @@
    * @param sign the sign of the number
    * @param value the only one digit of array
    */
-  BigInteger(int sign, int value) {
-    this.sign = sign;
-    numberLength = 1;
-    digits = new int[] {value};
+  BigInteger(int sign, int bits) {
+    this(sign, 1, new int[] {bits});
+  }
+
+  BigInteger(int sign, int lowBits, int highBits) {
+    this(sign, 2, new int[] {lowBits, highBits});
   }
 
   /**
-   * Creates a new {@code BigInteger} with the given sign and magnitude. This
-   * constructor does not create a copy, so any changes to the reference will
-   * affect the new number.
+   * Creates a new {@code BigInteger} with the given sign and magnitude. This constructor does not
+   * create a copy, so any changes to the reference will affect the new number.
    *
    * @param signum The sign of the number represented by {@code digits}
    * @param digits The magnitude of the number
@@ -466,8 +439,8 @@
   }
 
   /**
-   * Constructs a number without to create new space. This construct should be
-   * used only if the three fields of representation are known.
+   * Constructs a number without to create new space. This construct should be used only if the
+   * three fields of representation are known.
    *
    * @param sign the sign of the number
    * @param numberLength the length of the internal array
@@ -480,53 +453,13 @@
   }
 
   /**
-   * Creates a new {@code BigInteger} whose value is equal to the specified
-   * {@code long}.
-   *
-   * @param sign the sign of the number
-   * @param val the value of the new {@code BigInteger}.
-   */
-  BigInteger(int sign, long val) {
-    // PRE: (val >= 0) && (sign >= -1) && (sign <= 1)
-    this.sign = sign;
-    if (LongUtils.getHighBits(val) == 0) {
-      // It fits in one 'int'
-      numberLength = 1;
-      digits = new int[] {(int) val};
-    } else {
-      numberLength = 2;
-      digits = new int[] {(int) val, (int) (val >> 32)};
-    }
-  }
-
-  /**
-   * Creates a new {@code BigInteger} whose value is equal to the specified
-   * {@code double} (which must be an integral value).
-   *
-   * @param sign the sign of the number
-   * @param val the value of the new {@code BigInteger}.
-   */
-  private BigInteger(int sign, double val) {
-    // PRE: (val >= 0) && (sign >= -1) && (sign <= 1)
-    this.sign = sign;
-    if (val < POW32) {
-      // It fits in one 'int'
-      numberLength = 1;
-      digits = new int[] { toUnsignedInt(val) };
-    } else {
-      numberLength = 2;
-      digits = new int[] { toUnsignedInt(val % POW32), toUnsignedInt(val / POW32) };
-    }
-  }
-
-  /**
    * Returns a (new) {@code BigInteger} whose value is the absolute value of
    * {@code this}.
    *
    * @return {@code abs(this)}.
    */
   public BigInteger abs() {
-    return ((sign < 0) ? new BigInteger(1, numberLength, digits) : this);
+    return sign < 0 ? negate() : this;
   }
 
   /**
@@ -913,7 +846,7 @@
   public int intValue() {
     int i = digits[0];
     // i is always positive except for Integer.MIN_VALUE because of int overflow
-    return (sign > 0 || i == Integer.MIN_VALUE) ? i : -i;
+    return sign > 0 ? i : ensureInt(-i);
   }
 
   /**
@@ -1113,10 +1046,7 @@
    */
   public BigInteger multiply(BigInteger val) {
     // This let us to throw NullPointerException when val == null
-    if (val.sign == 0) {
-      return ZERO;
-    }
-    if (sign == 0) {
+    if (val.sign == 0 || sign == 0) {
       return ZERO;
     }
     return Multiplication.multiply(this, val);
@@ -1128,7 +1058,7 @@
    * @return {@code -this}.
    */
   public BigInteger negate() {
-    return ((sign == 0) ? this : new BigInteger(-sign, numberLength, digits));
+    return sign == 0 ? this : new BigInteger(-sign, numberLength, digits);
   }
 
   /**
diff --git a/user/test/com/google/gwt/emultest/java/math/BigIntegerConstructorsTest.java b/user/test/com/google/gwt/emultest/java/math/BigIntegerConstructorsTest.java
index 3229ee3..c3992e5 100644
--- a/user/test/com/google/gwt/emultest/java/math/BigIntegerConstructorsTest.java
+++ b/user/test/com/google/gwt/emultest/java/math/BigIntegerConstructorsTest.java
@@ -38,9 +38,6 @@
 package com.google.gwt.emultest.java.math;
 
 import com.google.gwt.emultest.java.util.EmulTestBase;
-import com.google.gwt.testing.TestUtils;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Target;
 import java.math.BigInteger;
 import java.util.Random;
 
@@ -778,48 +775,4 @@
     }
     assertEquals("incorrect sign", 1, aNumber.signum());
   }
-
-  /**
-   * Test internal static factory method.
-   */
-  public void testValueOfDouble() {
-    if (TestUtils.isJvm()) {
-      // JRE implementation doesn't have the method tested here
-      return;
-    }
-    BigInteger val = BigInteger.valueOf(noopToCompileForJvm(1.0));
-    assertEquals("1", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(100.0));
-    assertEquals("100", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(2147483647.0));
-    assertEquals("2147483647", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(-2147483647.0));
-    assertEquals("-2147483647", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(2147483648.0));
-    assertEquals("2147483648", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(-2147483648.0));
-    assertEquals("-2147483648", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(4294967295.0));
-    assertEquals("4294967295", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(-4294967295.0));
-    assertEquals("-4294967295", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(4294967296.0));
-    assertEquals("4294967296", val.toString());
-    val = BigInteger.valueOf(noopToCompileForJvm(-4294967296.0));
-    assertEquals("-4294967296", val.toString());
-  }
-
-  @Target({ElementType.METHOD})
-  private @interface GwtIncompatible {}
-
-  @GwtIncompatible
-  private static long noopToCompileForJvm(double d) {
-    // The BigInteger.valueOf(double) doesn't exist on JVM. This methods exists to so that this test
-    // can be compiled with the standard JRE.
-    throw new AssertionError();
-  }
-
-  private static double noopToCompileForJvm(Double d) {
-    return d;
-  }
 }