Implements missing 1.5 features from the Java number classes. IntegerTest is currently broken. Patch by: fabbott Review by: me (with reservations) git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@1609 8db76d5a-ed1c-0410-87a9-c151d255dfc7

diff --git a/user/super/com/google/gwt/emul/java/lang/Boolean.java b/user/super/com/google/gwt/emul/java/lang/Boolean.java
index 4b4f43b..6c2b46a 100644
--- a/user/super/com/google/gwt/emul/java/lang/Boolean.java
+++ b/user/super/com/google/gwt/emul/java/lang/Boolean.java

@@ -28,6 +28,13 @@
 
   // CHECKSTYLE_ON
 
+  public static Boolean parseString(String s) {
+    if (s != null && s.equalsIgnoreCase("true")) {
+      return TRUE;
+    }
+    return FALSE;
+  }
+
   public static String toString(boolean x) {
     return String.valueOf(x);
   }

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 d968e77..eacee7e 100644
--- a/user/super/com/google/gwt/emul/java/lang/Byte.java
+++ b/user/super/com/google/gwt/emul/java/lang/Byte.java

@@ -22,6 +22,7 @@
 
   public static final byte MIN_VALUE = (byte) 0x80;
   public static final byte MAX_VALUE = (byte) 0x7F;
+  public static final int SIZE = 8;
 
   // Box all values according to JLS
   private static Byte[] boxedValues = new Byte[256];
@@ -32,7 +33,7 @@
 
   /**
    * @skip
-   *
+   * 
    * Here for shared implementation with Arrays.hashCode
    */
   public static int hashCode(byte b) {

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 bd13405..ce65260 100644
--- a/user/super/com/google/gwt/emul/java/lang/Double.java
+++ b/user/super/com/google/gwt/emul/java/lang/Double.java

@@ -21,9 +21,16 @@
 public final class Double extends Number implements Comparable<Double> {
   public static final double MAX_VALUE = 1.7976931348623157e+308;
   public static final double MIN_VALUE = 4.9e-324;
+  public static final double MIN_NORMAL = 2.2250738585072014e-308;
+  public static final int MAX_EXPONENT = 1023; 
+                             // ==Math.getExponent(Double.MAX_VALUE);
+  public static final int MIN_EXPONENT = -1022; 
+                             // ==Math.getExponent(Double.MIN_NORMAL);;
+
   public static final double NaN = 0d / 0d;
   public static final double NEGATIVE_INFINITY = -1d / 0d;
   public static final double POSITIVE_INFINITY = 1d / 0d;
+  public static final int SIZE = 64;
 
   public static int compare(double x, double y) {
     if (x < y) {

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 8dd73fe..96e3fc0 100644
--- a/user/super/com/google/gwt/emul/java/lang/Float.java
+++ b/user/super/com/google/gwt/emul/java/lang/Float.java

@@ -21,9 +21,13 @@
 public final class Float extends Number implements Comparable<Float> {
   public static final float MAX_VALUE = 3.4028235e+38f;
   public static final float MIN_VALUE = 1.4e-45f;
+  public static final float MAX_EXPONENT = 127;
+  public static final float MIN_EXPONENT = -126;
+  public static final float MIN_NORMAL = 1.1754943508222875E-38f;
   public static final float NaN = 0f / 0f;
   public static final float NEGATIVE_INFINITY = -1f / 0f;
   public static final float POSITIVE_INFINITY = 1f / 0f;
+  public static final int SIZE = 32;
 
   public static int compare(float x, float y) {
     if (x < y) {

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 d21d1f0..4427deb 100644
--- a/user/super/com/google/gwt/emul/java/lang/Integer.java
+++ b/user/super/com/google/gwt/emul/java/lang/Integer.java

@@ -22,6 +22,7 @@
 
   public static final int MIN_VALUE = 0x80000000;
   public static final int MAX_VALUE = 0x7fffffff;
+  public static final int SIZE = 32;
 
   // Box values according to JLS - between -128 and 127
   private static Integer[] boxedValues = new Integer[256];
@@ -43,13 +44,61 @@
 
   /**
    * @skip
-   *
+   * 
    * Here for shared implementation with Arrays.hashCode
    */
   public static int hashCode(int i) {
     return i;
   }
 
+  public static int highestOneBit(int i) {
+    if (i < 0) {
+      return MIN_VALUE;
+    } else {
+      int rtn;
+      for (rtn = 0x40000000; (rtn >> 1) > i; rtn = rtn >> 1) {
+        // loop down until smaller
+      }
+      return rtn;
+    }
+  }
+
+  public static int lowestOneBit(int i) {
+    if (i == 0) {
+      return 32;
+    } else {
+      int r = 1;
+      while ((r & i) != 0) {
+        r = r * 2;
+      }
+      return r;
+    }
+  }
+
+  public static int numberOfLeadingZeros(int i) {
+    if (i < 0) {
+      return 0;
+    } else if (i == 0) {
+      return SIZE;
+    } else {
+      return SIZE - 1 - (int) Math.floor(Math.log(i) / Math.log(2.0d));
+    }
+  }
+
+  public static int numberOfTrailingZeros(int i) {
+    if (i < 0) {
+      return 0;
+    } else if (i == 0) {
+      return SIZE;
+    } else {
+      int rtn = 0;
+      for (int r = 1; (r & i) != 0; r = r * 2) {
+        rtn++;
+      }
+      return rtn;
+    }
+  }
+
   public static int parseInt(String s) throws NumberFormatException {
     return parseInt(s, 10);
   }
@@ -58,6 +107,49 @@
     return (int) __parseAndValidateLong(s, radix, MIN_VALUE, MAX_VALUE);
   }
 
+  public static int reverse(int i) {
+    int acc = 0;
+    int front = 0x80000000;
+    int back = 1;
+    int swing = 31;
+    while (swing > 15) {
+      acc = acc | ((i & front) >> swing) | ((i & back) << swing);
+      swing--;
+      front = front >> 1;
+      back = back << 1;
+    }
+    return acc;
+  }
+
+  public static int reverseBytes(int i) {
+    return ((i & 0xff) << 24) | ((i & 0xff00) << 8) | ((i & 0xff0000) >> 8)
+        | ((i & 0xff000000) >> 24);
+  }
+
+  public static int rotateLeft(int i, int distance) {
+    while (distance-- > 0) {
+      i = i << 1 | ((i < 0) ? 1 : 0);
+    }
+    return i;
+  }
+
+  public static int rotateRight(int i, int distance) {
+    while (distance-- > 0) {
+      i = ((i & 1) == 0 ? 0 : 0x80000000) | i >> 1;
+    }
+    return i;
+  }
+
+  public static int signum(int i) {
+    if (i == 0) {
+      return 0;
+    } else if (i < 0) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+
   public static String toBinaryString(int x) {
     return Long.toBinaryString(x);
   }

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 ba8e9e7..95c0c54 100644
--- a/user/super/com/google/gwt/emul/java/lang/Long.java
+++ b/user/super/com/google/gwt/emul/java/lang/Long.java

@@ -1,12 +1,12 @@
 /*
  * Copyright 2007 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
@@ -21,9 +21,20 @@
 public final class Long extends Number implements Comparable<Long> {
   public static final long MIN_VALUE = 0x8000000000000000L;
   public static final long MAX_VALUE = 0x7fffffffffffffffL;
+  public static final int SIZE = 64;
 
   // Box values according to JLS - between -128 and 127
   private static Long[] boxedValues = new Long[256];
+  
+  public static int bitCount (long i) {
+    int cnt = 0;
+    for (long q = MIN_VALUE; q > 0; q = q >> 1) {
+      if ((q & i) != 0) {
+        cnt++;
+      }
+    }
+    return cnt;
+  }
 
   public static Long decode(String s) throws NumberFormatException {
     return new Long(__decodeAndValidateLong(s, MIN_VALUE, MAX_VALUE));
@@ -36,6 +47,54 @@
     return (int) l;
   }
 
+  public static long highestOneBit (long i) {
+    if (i < 0) {
+      return MIN_VALUE;
+   } else {
+      long rtn;
+      for (rtn = 0x4000000000000000L; (rtn >> 1) > i; rtn = rtn >> 1) {
+        // loop down until smaller
+      }
+      return rtn;
+    }
+  }
+
+  public static long lowestOneBit (long i) {
+    if (i == 0) {
+      return SIZE;
+    } else {
+      long r = 1;
+      while ((r & i) != 0) {
+        r = r << 1;
+      }
+      return r;
+    }
+  }
+
+  public static int numberOfLeadingZeros(long i) {
+    if (i < 0) {
+      return 0;
+    } else if (i == 0) {
+      return SIZE;
+    } else {
+      return SIZE - 1 - (int)Math.floor(Math.log((double)i) / Math.log(2.0d));
+    }
+  }
+
+  public static int numberOfTrailingZeros(long i) {
+    if (i < 0) {
+      return 0;
+    } else if (i == 0) {
+      return SIZE;
+    } else {
+      int rtn = 0;
+      for (int r = 1; (r & i) != 0; r = r * 2) {
+        rtn++;
+      }
+      return rtn;
+    }
+  }
+
   public static long parseLong(String s) throws NumberFormatException {
     return parseLong(s, 10);
   }
@@ -45,6 +104,51 @@
     return __parseAndValidateLong(s, radix, MIN_VALUE, MAX_VALUE);
   }
 
+  public static long reverse (long i) {
+    long acc = 0;
+    long front = MIN_VALUE;
+    int back = 1;
+    int swing = SIZE - 1;
+    while (swing > 15) {
+      acc = acc | ((i & front) >> swing) | ((i & back) << swing);
+      swing--;
+      front = front >> 1;
+      back = back << 1;
+    }
+    return acc;
+  }
+
+  public static long reverseBytes (long i) {
+    return ((i & 0xffL) << 56) | ((i & 0xff00L) << 40)
+      | ((i & 0xff0000L) << 24) | ((i & 0xff000000L) << 8)
+      | ((i & 0xff00000000L) >> 8) | ((i & 0xff0000000000L) >> 24)
+      | ((i & 0xff000000000000L) >> 40) | ((i & 0xff00000000000000L) >> 56);
+  }
+
+  public static long rotateLeft (long i, int distance) {
+    while (distance-- > 0) {
+      i = i << 1 | ((i < 0) ? 1 : 0);
+    }
+    return i;
+  }
+
+  public static long rotateRight (long i, int distance) {
+    while (distance-- > 0) {
+      i = ((i & 1) == 0 ? 0 : 0x80000000) | i >> 1;
+    }
+    return i;
+  }
+
+  public static int signum (long i) {
+    if (i == 0) {
+      return 0;
+    } else if (i < 0) {
+     return -1;
+    } else {
+      return 1;
+    }
+  }
+
   public static String toBinaryString(long x) {
     if (x == 0) {
       return "0";
@@ -75,7 +179,7 @@
     return String.valueOf(b);
   }
 
-  public static Long valueOf(long i) {
+  public static Long valueOf (long i) {
     if (i > -129 && i < 128) {
       int rebase = (int) i + 128;
       if (boxedValues[rebase] == null) {

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 4d1d6fc..e7ef592 100644
--- a/user/super/com/google/gwt/emul/java/lang/Math.java
+++ b/user/super/com/google/gwt/emul/java/lang/Math.java

@@ -1,12 +1,12 @@
 /*
  * Copyright 2006 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
@@ -54,26 +54,88 @@
     return Math.atan(x);
   }-*/;
 
+  public static native double atan2 (double y, double x) /*-{
+    return Math.atan2(y,x);
+  }-*/;
+
+  /* NYI: Java 1.5 includes this, but JS doesn't give us the ingredients.: Java 1.5 includes this, but JS doesn't give us the ingredients.
+  public static double cbrt (double x) {
+    return 0;
+  }; */
+
   public static native double ceil(double x) /*-{
     return Math.ceil(x);
   }-*/;
 
+  public static double copySign (double magnitude, double sign) {
+    if (sign < 0) {
+      return (magnitude < 0) ? magnitude : -magnitude;
+    } else {
+      return (magnitude > 0) ? magnitude : -magnitude;
+    }
+  }
+
+  public static float copySign (float magnitude, float sign) {
+    return (float)(copySign((double)magnitude, (double)sign));
+  }
+
   public static native double cos(double x) /*-{
     return Math.cos(x);
   }-*/;
 
+  public static native double cosh(double x) /*-{
+    return (Math.exp(x) + Math.exp(-x)) / 2.0;
+  }-*/;
+
   public static native double exp(double x) /*-{
     return Math.exp(x);
   }-*/;
 
+  public static double expm1 (double d) {
+    if (d == 0.0 || Double.isNaN(d)) {
+      return d; // "a zero with same sign as argument", arg is zero, so...
+    } else if (!Double.isInfinite(d)) {
+      if (d < 0.0d) {
+        return -1.0d;
+      } else {
+        return Double.POSITIVE_INFINITY;
+      }
+    }
+    return exp(d) + 1.0d;
+  }
+
   public static native double floor(double x) /*-{
     return Math.floor(x);
   }-*/;
 
+  /* NYI: Java 1.5 includes this, but JS doesn't give us the ingredients.
+  public static int getExponent (double d) {
+  }
+
+  public static int getExponent (float f) {
+  }
+  */
+
+  public static double hypot(double x, double y) {
+    return sqrt(x * x + y * y);
+  }
+
+  /* NYI: Java 1.5 includes this, but JS doesn't give us the ingredients.
+  public static double IEEEremainder(double f1, double f2) {
+  } */
+
   public static native double log(double x) /*-{
     return Math.log(x);
   }-*/;
 
+  public static double log10 (double x) {
+    return Math.log(x) / Math.log(10);
+  }
+
+  public static double log1p(double x) {
+    return Math.log(x + 1.0d);
+  };
+
   public static double max(double x, double y) {
     return x > y ? x : y;
   }
@@ -106,6 +168,19 @@
     return x < y ? x : y;
   }
 
+  /* NYI: Java 1.5 includes this, but JS doesn't give us the ingredients.
+  public static double nextAfter(double start, double direction) {
+  }
+  public static float nextAfter(float start, float direction) {
+  }
+  public static double nextUp(double start) {
+    return nextAfter(start, 1.0d);
+  }
+  public static float nextUp(float start) {
+    return nextAfter(start,1.0f);
+  }
+  */
+
   public static native double pow(double x, double exp) /*-{
     return Math.pow(x, exp);
   }-*/;
@@ -114,6 +189,18 @@
     return Math.random();
   }-*/;
 
+  public static double rint (double d) {
+    if (Double.isNaN(d)) {
+      return d;
+    } else if (Double.isInfinite(d)) {
+      return d;
+    } else if (d == 0.0d) {
+      return d;
+    } else {
+      return (double)(round(d));
+    }
+  };
+
   public static native long round(double x) /*-{
     return Math.round(x);
   }-*/;
@@ -122,10 +209,53 @@
     return Math.round(x);
   }-*/;
 
+  public static double scalb (double d, int scaleFactor) {
+    if (scaleFactor > 0) {
+      return d * (1 << scaleFactor);
+    } else if (scaleFactor == 0) {
+      return d;
+    } else {
+      return d * 1.0d / (1 << -scaleFactor);
+    }
+  }
+
+  public static float scalb (float f, int scaleFactor) {
+    if (scaleFactor > 0) {
+      return f * (1 << scaleFactor);
+    } else if (scaleFactor == 0) {
+      return f;
+    } else {
+      return f * 1.0f / (1 << -scaleFactor);
+    }
+  }
+
+  public static double signum (double d) {
+    if (d > 0.0d) {
+      return 1.0d;
+    } else if (d < 0.0d) {
+      return -1.0d;
+    } else {
+      return 0.0d;
+    }
+  }
+
+  public static float signum (float f) {
+    if (f > 0.0f) {
+      return 1.0f;
+    } else if (f < 0.0f) {
+      return -1.0f;
+    } else {
+      return 0.0f;
+    }
+  }
   public static native double sin(double x) /*-{
     return Math.sin(x);
   }-*/;
 
+  public static native double sinh(double x) /*-{
+    return Math.sinh(x);
+  }-*/;
+
   public static native double sqrt(double x) /*-{
     return Math.sqrt(x);
   }-*/;
@@ -134,6 +264,10 @@
     return Math.tan(x);
   }-*/;
 
+  public static native double tanh(double x) /*-{
+    return Math.tanh(x);
+  }-*/;
+
   public static double toDegrees(double x) {
     return x * PI_UNDER_180;
   }
@@ -141,4 +275,11 @@
   public static double toRadians(double x) {
     return x * PI_OVER_180;
   }
+
+  /* NYI: Java 1.5 includes this, but JS doesn't give us the ingredients.
+  public static double ulp (double x) {
+  };
+  public static float ulp (float x) {
+  };
+  */
 }

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 20f7197..30fa5a4 100644
--- a/user/super/com/google/gwt/emul/java/lang/Short.java
+++ b/user/super/com/google/gwt/emul/java/lang/Short.java

@@ -1,12 +1,12 @@
 /*
  * Copyright 2007 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
@@ -22,6 +22,7 @@
 
   public static final short MIN_VALUE = (short) 0x8000;
   public static final short MAX_VALUE = (short) 0x7fff;
+  public static final int SIZE = 16;
 
   // Box values according to JLS - between -128 and 127
   private static Short[] boxedValues = new Short[256];
@@ -46,6 +47,10 @@
     return (short) __parseAndValidateLong(s, radix, MIN_VALUE, MAX_VALUE);
   }
 
+  public static short reverseBytes (short s) {
+    return (short)(((s & 0xff) << 8) | ((s & 0xff00) >> 8));
+  }
+
   public static String toString(short b) {
     return String.valueOf(b);
   }

diff --git a/user/test/com/google/gwt/emultest/EmulSuite.java b/user/test/com/google/gwt/emultest/EmulSuite.java
index 90e7e55..c757ea7 100644
--- a/user/test/com/google/gwt/emultest/EmulSuite.java
+++ b/user/test/com/google/gwt/emultest/EmulSuite.java

@@ -1,12 +1,12 @@
 /*
  * Copyright 2007 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
@@ -15,9 +15,14 @@
  */
 package com.google.gwt.emultest;
 
+import com.google.gwt.emultest.java.lang.BooleanTest;
+import com.google.gwt.emultest.java.lang.ByteTest;
 import com.google.gwt.emultest.java.lang.CharacterTest;
+import com.google.gwt.emultest.java.lang.DoubleTest;
 import com.google.gwt.emultest.java.lang.IntegerTest;
+import com.google.gwt.emultest.java.lang.LongTest;
 import com.google.gwt.emultest.java.lang.ObjectTest;
+import com.google.gwt.emultest.java.lang.ShortTest;
 import com.google.gwt.emultest.java.lang.StringBufferTest;
 import com.google.gwt.emultest.java.lang.StringTest;
 import com.google.gwt.emultest.java.util.ArraysTest;
@@ -30,24 +35,30 @@
 import junit.framework.TestSuite;
 
 /**
- * Tests all classes in GWT JRE emulation library.
+ * TODO: document me.
  */
 public class EmulSuite {
 
+  /** Note: due to compiler error, only can use one Test Case at a time. */
   public static Test suite() {
     TestSuite suite = new TestSuite("Tests for com.google.gwt.emul.java");
 
     // $JUnit-BEGIN$
     suite.addTestSuite(ArraysTest.class);
+    suite.addTestSuite(BooleanTest.class);
+    suite.addTestSuite(ByteTest.class);
     suite.addTestSuite(HashMapTest.class);
     suite.addTestSuite(StringBufferTest.class);
     suite.addTestSuite(StringTest.class);
     suite.addTestSuite(CharacterTest.class);
     suite.addTestSuite(StackTest.class);
     suite.addTestSuite(IntegerTest.class);
+    suite.addTestSuite(LongTest.class);
+    suite.addTestSuite(DoubleTest.class);
     suite.addTestSuite(DateTest.class);
     suite.addTestSuite(HashSetTest.class);
     suite.addTestSuite(ObjectTest.class);
+    suite.addTestSuite(ShortTest.class);
     // $JUnit-END$
 
     return suite;

diff --git a/user/test/com/google/gwt/emultest/java/lang/BooleanTest.java b/user/test/com/google/gwt/emultest/java/lang/BooleanTest.java
new file mode 100644
index 0000000..f99fbe3
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/lang/BooleanTest.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2007 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.java.lang;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests for the JRE Boolean type.
+ */
+public class BooleanTest extends GWTTestCase {
+
+  public String getModuleName() {
+    return "com.google.gwt.emultest.EmulSuite";
+  }
+
+  public void testStatics() {
+    // test the "new" 1.5 statics, for now assuming "old" rest works
+    assertEquals(true, Boolean.valueOf(true).booleanValue());
+    assertEquals(false, Boolean.valueOf(false).booleanValue());
+    assertEquals(true, Boolean.valueOf("true").booleanValue());
+    assertEquals(true, Boolean.valueOf("tRuE").booleanValue());
+    assertEquals(false, Boolean.valueOf(null).booleanValue());
+    assertEquals(false, Boolean.valueOf("yes").booleanValue());
+    assertEquals(false, Boolean.valueOf("").booleanValue());
+  }
+}

diff --git a/user/test/com/google/gwt/emultest/java/lang/ByteTest.java b/user/test/com/google/gwt/emultest/java/lang/ByteTest.java
new file mode 100644
index 0000000..14361e0
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/lang/ByteTest.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2007 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.java.lang;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests for the JRE Byte type.
+ */
+public class ByteTest extends GWTTestCase {
+
+  public String getModuleName() {
+    return "com.google.gwt.emultest.EmulSuite";
+  }
+
+  public void testStatics() {
+    // test the new 1.5 statics... older stuff "assumed to work"
+    assertEquals(0, Byte.valueOf((byte) 0).intValue());
+    assertEquals(127, Byte.valueOf((byte) 127).intValue());
+    assertEquals(-128, Byte.valueOf((byte) -128).intValue());
+    assertEquals(-1, Byte.valueOf((byte) 255).intValue());
+  }
+
+  public void testConstants() {
+    assertEquals(-128, Byte.MIN_VALUE);
+    assertEquals(127, Byte.MAX_VALUE);
+    assertEquals(8, Byte.SIZE);
+  }
+}

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 4d6edaa..ff33ebe 100644
--- a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java

@@ -19,7 +19,7 @@
 import com.google.gwt.junit.client.GWTTestCase;
 
 /**
- * TODO: document me.
+ * Unit tests for the emulated-in-Javascript Double/double autoboxed types.
  */
 public class DoubleTest extends GWTTestCase {
 
@@ -57,6 +57,9 @@
     assertTrue(Double.NEGATIVE_INFINITY < Double.POSITIVE_INFINITY);
     assertTrue(Double.MIN_VALUE < Double.MAX_VALUE);
     assertFalse(Double.NaN == Double.NaN);
+    assertEquals(64, Double.SIZE);
+    // jdk1.6  assertEquals(Math.getExponent(Double.MAX_VALUE), Double.MAX_EXPONENT);
+    // jdk1.6  assertEquals(Math.getExponent(Double.MIN_NORMAL), Double.MIN_EXPONENT);
   }
 
   public void testParse() {

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 5c145d2..4ddbc55 100644
--- a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java

@@ -19,7 +19,8 @@
 import com.google.gwt.junit.client.GWTTestCase;
 
 /**
- * TODO: document me.
+ * Unit tests for the Javascript emulation of the Float/float autoboxed 
+ * fundamental type.
  */
 public class FloatTest extends GWTTestCase {
 
@@ -57,6 +58,9 @@
     assertTrue(Float.NEGATIVE_INFINITY < Float.POSITIVE_INFINITY);
     assertTrue(Float.MIN_VALUE < Float.MAX_VALUE);
     assertFalse(Float.NaN == Float.NaN);
+    assertEquals(Float.SIZE, 32);
+    // jdk1.6 assertEquals(Float.MIN_EXPONENT, Math.getExponent(Float.MIN_NORMAL));
+    // jdk1.6 assertEquals(Float.MAX_EXPONENT, Math.getExponent(Float.MAX_VALUE));
   }
 
   public void testParse() {

diff --git a/user/test/com/google/gwt/emultest/java/lang/IntegerTest.java b/user/test/com/google/gwt/emultest/java/lang/IntegerTest.java
index a53c08a..1a43fbc 100644
--- a/user/test/com/google/gwt/emultest/java/lang/IntegerTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/IntegerTest.java

@@ -1,12 +1,12 @@
 /*
  * Copyright 2007 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
@@ -18,7 +18,8 @@
 import com.google.gwt.junit.client.GWTTestCase;
 
 /**
- * TODO: document me.
+ * Unit tests for the Javascript emulation of the Integer/int autoboxed
+ * fundamental type.
  */
 public class IntegerTest extends GWTTestCase {
 
@@ -26,16 +27,6 @@
     return "com.google.gwt.emultest.EmulSuite";
   }
 
-  public void testConstructor() {
-    assertEquals(12345, new Integer(12345).intValue());
-    assertEquals(12345, new Integer("12345").intValue());
-  }
-
-  public void testToString() {
-    assertEquals("12345", new Integer(12345).toString());
-    assertEquals("-12345", new Integer("-12345").toString());
-  }
-
   public void testBadStrings() {
     try {
       new Integer("05abcd");
@@ -57,52 +48,73 @@
     } catch (NumberFormatException e) {
       // Expected behavior
     }
-    
+
     try {
       Integer.parseInt(String.valueOf(Long.MAX_VALUE));
       fail("parseInt should reject numbers greater than the range of int");
     } catch (NumberFormatException e) {
       // Expected behavior
     }
-    
+
     try {
       Integer.parseInt(String.valueOf(Long.MIN_VALUE));
       fail("parseInt should reject numbers less than the range of int");
     } catch (NumberFormatException e) {
       // Expected behavior
     }
-    
+
     try {
-      Integer.parseInt(String.valueOf((long)Integer.MAX_VALUE + 1));
+      Integer.parseInt(String.valueOf((long) Integer.MAX_VALUE + 1));
       fail("parseInt should reject numbers greater than the range of int");
     } catch (NumberFormatException e) {
       // Expected behavior
     }
-    
+
     try {
-      Integer.parseInt(String.valueOf((long)Integer.MIN_VALUE - 1));
+      Integer.parseInt(String.valueOf((long) Integer.MIN_VALUE - 1));
       fail("parseInt should reject numbers less than the range of int");
     } catch (NumberFormatException e) {
       // Expected behavior
     }
   }
 
+  public void testBinaryString() {
+    assertEquals("11000000111001", Integer.toBinaryString(12345));
+    assertEquals("0", Integer.toBinaryString(0));
+    assertEquals("11111111111111111100111111000111",
+        Integer.toBinaryString(-12345));
+  }
+
+  public void testBitCount() {
+    assertEquals(0, Integer.bitCount(0));
+    assertEquals(1, Integer.bitCount(1));
+    assertEquals(32, Integer.bitCount(-1));
+    assertEquals(31, Integer.bitCount(Integer.MAX_VALUE));
+    assertEquals(1, Integer.bitCount(Integer.MIN_VALUE));
+  }
+
   public void testCompareTo() {
     assertEquals(-1, new Integer(12345).compareTo(new Integer(12346)));
     assertEquals(1, new Integer("12345").compareTo(new Integer(12344)));
     assertEquals(0, new Integer("12345").compareTo(new Integer(12345)));
   }
 
-  public void testEquals() {
-    assertFalse(new Integer(12345).equals(new Integer(12346)));
-    assertEquals(new Integer("12345"), new Integer(12345));
+  public void testConstants() {
+    assertEquals(32, Integer.SIZE);
+    assertEquals(0x7fffffff, Integer.MAX_VALUE);
+    assertEquals(0x80000000, Integer.MIN_VALUE);
+  }
+
+  public void testConstructor() {
+    assertEquals(12345, new Integer(12345).intValue());
+    assertEquals(12345, new Integer("12345").intValue());
   }
 
   public void testDecode() {
-    assertEquals(Integer.MAX_VALUE,
-        Integer.decode(String.valueOf(Integer.MAX_VALUE)).intValue());
-    assertEquals(Integer.MIN_VALUE,
-        Integer.decode(String.valueOf(Integer.MIN_VALUE)).intValue());
+    assertEquals(Integer.MAX_VALUE, Integer.decode(
+        String.valueOf(Integer.MAX_VALUE)).intValue());
+    assertEquals(Integer.MIN_VALUE, Integer.decode(
+        String.valueOf(Integer.MIN_VALUE)).intValue());
     assertEquals(12345, Integer.decode("12345").intValue());
     assertEquals(31, Integer.decode("0x1f").intValue());
     assertEquals(-31, Integer.decode("-0X1F").intValue());
@@ -116,10 +128,106 @@
     }
   }
 
+  public void testEquals() {
+    assertFalse(new Integer(12345).equals(new Integer(12346)));
+    assertEquals(new Integer("12345"), new Integer(12345));
+  }
+
   public void testHashCode() {
     assertEquals(1234, new Integer(1234).hashCode());
   }
 
+  public void testHexString() {
+    assertEquals("3039", Integer.toHexString(12345));
+    assertEquals("0", Integer.toHexString(0));
+    assertEquals("ffffcfc7", Integer.toHexString(-12345));
+  }
+
+  public void testHighestOneBit() {
+    assertEquals(0, Integer.highestOneBit(0));
+    assertEquals(Integer.MIN_VALUE, Integer.highestOneBit(-1));
+    assertEquals(Integer.MIN_VALUE, Integer.highestOneBit(-256));
+    assertEquals(1, Integer.highestOneBit(1));
+    assertEquals(0x80, Integer.highestOneBit(0x80));
+    assertEquals(0x40000000, Integer.highestOneBit(Integer.MAX_VALUE));
+  }
+
+  public void testLowestOneBit() {
+    assertEquals(0, Integer.lowestOneBit(0));
+    assertEquals(1, Integer.lowestOneBit(-1));
+    assertEquals(0x100, Integer.lowestOneBit(-256));
+    assertEquals(1, Integer.lowestOneBit(1));
+    assertEquals(0x80, Integer.lowestOneBit(0x80));
+    assertEquals(0x80000000, Integer.lowestOneBit(Integer.MIN_VALUE));
+  }
+
+  public void testNumberOfLeadingZeros() {
+    assertEquals(32, Integer.numberOfLeadingZeros(0));
+    assertEquals(31, Integer.numberOfLeadingZeros(1));
+    assertEquals(0, Integer.numberOfLeadingZeros(-1));
+    assertEquals(16, Integer.numberOfLeadingZeros(0x8000));
+    assertEquals(1, Integer.numberOfLeadingZeros(Integer.MAX_VALUE));
+    assertEquals(0, Integer.numberOfLeadingZeros(Integer.MIN_VALUE));
+    assertEquals(0, Integer.numberOfLeadingZeros(-0x8000));
+  }
+
+  public void testNumberOfTrailingZeros() {
+    assertEquals(32, Integer.numberOfTrailingZeros(0));
+    assertEquals(0, Integer.numberOfTrailingZeros(1));
+    assertEquals(0, Integer.numberOfTrailingZeros(-1));
+    assertEquals(15, Integer.numberOfTrailingZeros(0x8000));
+    assertEquals(0, Integer.numberOfTrailingZeros(Integer.MAX_VALUE));
+    assertEquals(31, Integer.numberOfTrailingZeros(Integer.MIN_VALUE));
+    assertEquals(4, Integer.numberOfTrailingZeros(-0x7ff0));
+  }
+
+  public void testReverse() {
+    assertEquals(0, Integer.reverse(0));
+    assertEquals(-1, Integer.reverse(-1));
+    assertEquals(Integer.MIN_VALUE, Integer.reverse(1));
+    assertEquals(1, Integer.reverse(Integer.MIN_VALUE));
+    assertEquals(0xaaaaaaaa, Integer.reverse(0x55555555));
+  }
+
+  public void testReverseBytes() {
+  }
+
+  public void testRotateLeft() {
+    assertEquals(0, Integer.rotateLeft(0, 4));
+    assertEquals(0x2, Integer.rotateLeft(1, 1));
+    assertEquals(0x10, Integer.rotateLeft(1, 4));
+    assertEquals(-1, Integer.rotateLeft(-1, 4));
+    assertEquals(Integer.MIN_VALUE, Integer.rotateLeft(0x40000000, 1));
+    assertEquals(1, Integer.rotateLeft(Integer.MIN_VALUE, 1));
+  }
+
+  public void testRotateRight() {
+    assertEquals(0, Integer.rotateRight(0, 4));
+    assertEquals(Integer.MIN_VALUE, Integer.rotateRight(1, 1));
+    assertEquals(0x10000000, Integer.rotateRight(1, 4));
+    assertEquals(-1, Integer.rotateRight(-1, 4));
+  }
+
+  public void testSignum() {
+    assertEquals(0, Integer.signum(0));
+    assertEquals(1, Integer.signum(1));
+    assertEquals(-1, Integer.signum(-1));
+    assertEquals(1, Integer.signum(Integer.MAX_VALUE));
+    assertEquals(-1, Integer.signum(Integer.MIN_VALUE));
+  }
+
+  public void testStaticValueOf() {
+    assertEquals(Integer.MIN_VALUE,
+        Integer.valueOf(Integer.MIN_VALUE).intValue());
+    assertEquals(Integer.MAX_VALUE,
+        Integer.valueOf(Integer.MAX_VALUE).intValue());
+  }
+
+  public void testToString() {
+    assertEquals("12345", new Integer(12345).toString());
+    assertEquals("-12345", new Integer("-12345").toString());
+  }
+
   public void testValueOf() {
     assertEquals(new Integer(12345), Integer.valueOf("12345"));
     assertEquals(new Integer(1865), Integer.valueOf("12345", 6));
@@ -127,30 +235,20 @@
     assertEquals(1865, Integer.parseInt("12345", 6));
   }
 
-  public void testHexString() {
-    assertEquals("3039", Integer.toHexString(12345));
-    assertEquals("0", Integer.toHexString(0));
-    assertEquals("ffffcfc7", Integer.toHexString(-12345));
-  }
-
-  public void testBinaryString() {
-    assertEquals("11000000111001", Integer.toBinaryString(12345));
-    assertEquals("0", Integer.toBinaryString(0));
-    assertEquals("11111111111111111100111111000111", Integer.toBinaryString(-12345));
-  }
-
   public void testXValue() {
-    assertEquals("short",(short) 12345, new Integer(12345).shortValue());
+    assertEquals("short", (short) 12345, new Integer(12345).shortValue());
     assertEquals("long", 1234567890L, new Integer(1234567890).longValue());
-    assertEquals("double", 12345d, new Integer(12345).doubleValue(),0.001);
-    assertEquals("float",12345f, new Integer(12345).floatValue(),0.01);
+    assertEquals("double", 12345d, new Integer(12345).doubleValue(), 0.001);
+    assertEquals("float", 12345f, new Integer(12345).floatValue(), 0.01);
     assertEquals("byte", (byte) 123, new Integer(123).byteValue());
-    assertEquals("integer",123, new Integer(123).intValue());
-    assertEquals("short overflow", (short) 10713, new Integer(1234512345).shortValue());
-    assertEquals("double2", 1234512345d, new Integer(1234512345).doubleValue(), 0.001);
+    assertEquals("integer", 123, new Integer(123).intValue());
+    assertEquals("short overflow", (short) 10713,
+        new Integer(1234512345).shortValue());
+    assertEquals("double2", 1234512345d, new Integer(1234512345).doubleValue(),
+        0.001);
     // Invalid test right now; we don't coerce to single precision
-    // assertEquals("float2",1234512345f, new Integer(1234512345).floatValue(),0.001);
-    assertEquals("byte overflow",(byte) -13, new Integer(123123).byteValue());
+    // assertEquals("float2",1234512345f, new
+    // Integer(1234512345).floatValue(),0.001);
+    assertEquals("byte overflow", (byte) -13, new Integer(123123).byteValue());
   }
-
 }

diff --git a/user/test/com/google/gwt/emultest/java/lang/ShortTest.java b/user/test/com/google/gwt/emultest/java/lang/ShortTest.java
new file mode 100644
index 0000000..d23d5cd
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/lang/ShortTest.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2007 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.java.lang;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests for the JRE Short type.
+ */
+public class ShortTest extends GWTTestCase {
+
+  public String getModuleName() {
+    return "com.google.gwt.emultest.EmulSuite";
+  }
+
+  public void testConstants() {
+    assertEquals(16, Short.SIZE);
+    assertEquals((short) 0x7fff, Short.MAX_VALUE);
+    assertEquals((short) 0x8000, Short.MIN_VALUE);
+  }
+
+  public void testReverseBytes() {
+    assertEquals(0x1122, Short.reverseBytes((short) 0x2211));
+    assertEquals(0, Short.reverseBytes((short) 0));
+  }
+
+  public void testStaticValueOf() {
+    assertEquals(Short.MIN_VALUE, Short.valueOf(Short.MIN_VALUE).shortValue());
+    assertEquals(Short.MAX_VALUE, Short.valueOf(Short.MAX_VALUE).shortValue());
+  }
+}