Externalize test code

Change-Id: Iab19397c7a72fb9a3ca63bfd0bc4eaf1a98138ba

16 files changed, 988 insertions, 0 deletions

diff --git a/test/AllFields/AllFields.java b/test/AllFields/AllFields.java
new file mode 100644
index 0000000..86b8841
--- /dev/null
+++ b/test/AllFields/AllFields.java
@@ -0,0 +1,25 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class AllFields {
+    static boolean sZ;
+    static byte sB;
+    static char sC;
+    static double sD;
+    static float sF;
+    static int sI;
+    static long sJ;
+    static short sS;
+    static Object sObject;
+    static Object[] sObjectArray;
+
+    boolean iZ;
+    byte iB;
+    char iC;
+    double iD;
+    float iF;
+    int iI;
+    long iJ;
+    short iS;
+    Object iObject;
+    Object[] iObjectArray;
+}
diff --git a/test/CreateMethodDescriptor/CreateMethodDescriptor.java b/test/CreateMethodDescriptor/CreateMethodDescriptor.java
new file mode 100644
index 0000000..aa1f3de
--- /dev/null
+++ b/test/CreateMethodDescriptor/CreateMethodDescriptor.java
@@ -0,0 +1,6 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class CreateMethodDescriptor {
+    Float m1(int a, double b, long c, Object d) { return null; }
+    CreateMethodDescriptor m2(boolean x, short y, char z) { return null; }
+}
diff --git a/test/Fibonacci/Fibonacci.java b/test/Fibonacci/Fibonacci.java
new file mode 100644
index 0000000..5137205
--- /dev/null
+++ b/test/Fibonacci/Fibonacci.java
@@ -0,0 +1,30 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class Fibonacci {
+
+    static int fibonacci(int n) {
+        if (n == 0) {
+            return 0;
+        }
+        int x = 1;
+        int y = 1;
+        for (int i = 3; i <= n; i++) {
+            int z = x + y;
+            x = y;
+            y = z;
+        }
+        return y;
+    }
+
+    public static void main(String[] args) {
+        try {
+            if (args.length == 1) {
+                int x = Integer.parseInt(args[0]);
+                int y = fibonacci(x); /* to warm up cache */
+                System.out.printf("fibonacci(%d)=%d\n", x, y);
+                y = fibonacci(x +1);
+                System.out.printf("fibonacci(%d)=%d\n", x, y);
+            }
+        } catch (NumberFormatException ex) {}
+    }
+}
diff --git a/test/IntMath/IntMath.java b/test/IntMath/IntMath.java
new file mode 100644
index 0000000..c13a79a
--- /dev/null
+++ b/test/IntMath/IntMath.java
@@ -0,0 +1,805 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class IntMath {
+
+    public static boolean mBoolean1, mBoolean2;
+    public static byte mByte1, mByte2;
+    public static char mChar1, mChar2;
+    public static short mShort1, mShort2;
+    public static int mInt1, mInt2;
+    public static float mFloat1, mFloat2;
+    public static long mLong1, mLong2;
+    public static double mDouble1, mDouble2;
+    public static volatile long mVolatileLong1, mVolatileLong2;
+
+
+    private int foo_;
+
+    public IntMath(int stuff) {
+        foo_ = stuff;
+    }
+
+    public IntMath() {
+        foo_ = 123;
+    }
+
+    static int staticFieldTest(int x) {
+        mBoolean1 = true;
+        mBoolean2 = false;
+        mByte1 = 127;
+        mByte2 = -128;
+        mChar1 = 32767;
+        mChar2 = 65535;
+        mShort1 = 32767;
+        mShort2 = -32768;
+        mInt1 = 65537;
+        mInt2 = -65537;
+        mFloat1 = 3.1415f;
+        mFloat2 = -1.0f / 0.0f;                // -inf
+        mLong1 = 1234605616436508552L;     // 0x1122334455667788
+        mLong2 = -1234605616436508552L;
+        mDouble1 = 3.1415926535;
+        mDouble2 = 1.0 / 0.0;               // +inf
+        mVolatileLong1 = mLong1 - 1;
+        mVolatileLong2 = mLong2 + 1;
+
+        if (!mBoolean1) { return 10; }
+        if (mBoolean2) { return 11; }
+        if (mByte1 != 127) { return 12; }
+        if (mByte2 != -128) { return 13; }
+        if (mChar1 != 32767) { return 14; }
+        if (mChar2 != 65535) { return 15; }
+        if (mShort1 != 32767) { return 16; }
+        if (mShort2 != -32768) { return 17; }
+        if (mInt1 != 65537) { return 18; }
+        if (mInt2 != -65537) { return 19; }
+        if (!(mFloat1 > 3.141f && mFloat1 < 3.142f)) { return 20; }
+        if (mFloat2 >= mFloat1) { return 21; }
+        if (mLong1 != 1234605616436508552L) { return 22; }
+        if (mLong2 != -1234605616436508552L) { return 23; }
+        if (!(mDouble1 > 3.141592653 && mDouble1 < 3.141592654)) { return 24; }
+        if (mDouble2 <= mDouble1) { return 25; }
+        if (mVolatileLong1 != 1234605616436508551L) { return 26; }
+        if (mVolatileLong2 != -1234605616436508551L) { return 27; }
+
+        return 1000 + x;
+    }
+
+    /*
+     * Try to cause some unary operations.
+     */
+    static int unopTest(int x) {
+        x = -x;
+        x ^= 0xffffffff;
+        return x;
+    }
+
+    static int shiftTest1() {
+        final int[] mBytes = {
+            0x11, 0x22, 0x33, 0x44, 0x88, 0x99, 0xaa, 0xbb
+        };
+        long l;
+        int i1, i2;
+
+        if (mBytes[0] != 0x11) return 20;
+        if (mBytes[1] != 0x22) return 21;
+        if (mBytes[2] != 0x33) return 22;
+        if (mBytes[3] != 0x44) return 23;
+        if (mBytes[4] != 0x88) return 24;
+        if (mBytes[5] != 0x99) return 25;
+        if (mBytes[6] != 0xaa) return 26;
+        if (mBytes[7] != 0xbb) return 27;
+
+        i1 = mBytes[0] | mBytes[1] << 8 | mBytes[2] << 16 | mBytes[3] << 24;
+        i2 = mBytes[4] | mBytes[5] << 8 | mBytes[6] << 16 | mBytes[7] << 24;
+        l = i1 | ((long)i2 << 32);
+
+        if (i1 != 0x44332211) { return 0x80000000 | i1; }
+        if (i2 != 0xbbaa9988) { return 2; }
+        if (l != 0xbbaa998844332211L) { return 3; }
+
+        l = (long)mBytes[0]
+                | (long)mBytes[1] << 8
+                | (long)mBytes[2] << 16
+                | (long)mBytes[3] << 24
+                | (long)mBytes[4] << 32
+                | (long)mBytes[5] << 40
+                | (long)mBytes[6] << 48
+                | (long)mBytes[7] << 56;
+
+        if (l != 0xbbaa998844332211L) { return 4; }
+        return 0;
+    }
+
+    static int shiftTest2() {
+
+        long    a = 0x11;
+        long    b = 0x22;
+        long    c = 0x33;
+        long    d = 0x44;
+        long    e = 0x55;
+        long    f = 0x66;
+        long    g = 0x77;
+        long    h = 0x88;
+
+        long    result = ((a << 56) | (b << 48) | (c << 40) | (d << 32) |
+                          (e << 24) | (f << 16) | (g <<  8) | h);
+
+        if (result != 0x1122334455667788L) { return 1; }
+        return 0;
+    }
+
+    static int unsignedShiftTest() {
+        byte b = -4;
+        short s = -4;
+        char c = 0xfffc;
+        int i = -4;
+
+        b >>>= 4;
+        s >>>= 4;
+        c >>>= 4;
+        i >>>= 4;
+
+        if ((int) b != -1) { return 1; }
+        if ((int) s != -1) { return 2; }
+        if ((int) c != 0x0fff) { return 3; }
+        if (i != 268435455) { return 4; }
+        return 0;
+    }
+
+    static int convTest() {
+
+        float f;
+        double d;
+        int i;
+        long l;
+
+        /* int --> long */
+        i = 7654;
+        l = (long) i;
+        if (l != 7654L) { return 1; }
+
+        i = -7654;
+        l = (long) i;
+        if (l != -7654L) { return 2; }
+
+        /* long --> int (with truncation) */
+        l = 5678956789L;
+        i = (int) l;
+        if (i != 1383989493) { return 3; }
+
+        l = -5678956789L;
+        i = (int) l;
+        if (i != -1383989493) { return 4; }
+        return 0;
+    }
+
+    static int charSubTest() {
+
+        char char1 = 0x00e9;
+        char char2 = 0xffff;
+        int i;
+
+        /* chars are unsigned-expanded to ints before subtraction */
+        i = char1 - char2;
+        if (i != 0xffff00ea) { return 1; }
+        return 0;
+    }
+
+    /*
+     * We pass in the arguments and return the results so the compiler
+     * doesn't do the math for us.  (x=70000, y=-3)
+     */
+    static int intOperTest(int x, int y) {
+        int[] results = new int[10];
+
+        /* this seems to generate "op-int" instructions */
+        results[0] = x + y;
+        results[1] = x - y;
+        results[2] = x * y;
+        results[3] = x * x;
+        results[4] = x / y;
+        results[5] = x % -y;
+        results[6] = x & y;
+        results[7] = x | y;
+        results[8] = x ^ y;
+
+        /* this seems to generate "op-int/2addr" instructions */
+        results[9] = x + ((((((((x + y) - y) * y) / y) % y) & y) | y) ^ y);
+
+        /* check this edge case while we're here (div-int/2addr) */
+        int minInt = -2147483648;
+        int negOne = -results[5];
+        int plusOne = 1;
+        int result = (((minInt + plusOne) - plusOne) / negOne) / negOne;
+
+        if (result != minInt) { return 1;};
+        if (results[0] != 69997) { return 2;};
+        if (results[1] != 70003) { return 3;};
+        if (results[2] != -210000) { return 4;};
+        if (results[3] != 605032704) { return 5;};
+        if (results[4] != -23333) { return 6;};
+        if (results[5] != 1) { return 7;};
+        if (results[6] != 70000) { return 8;};
+        if (results[7] != -3) { return 9;};
+        if (results[8] != -70003) { return 10;};
+        if (results[9] != 70000) { return 11;};
+
+        return 0;
+    }
+
+    /*
+     * More operations, this time with 16-bit constants.  (x=77777)
+     */
+    static int lit16Test(int x) {
+
+        int[] results = new int[8];
+
+        /* try to generate op-int/lit16" instructions */
+        results[0] = x + 1000;
+        results[1] = 1000 - x;
+        results[2] = x * 1000;
+        results[3] = x / 1000;
+        results[4] = x % 1000;
+        results[5] = x & 1000;
+        results[6] = x | -1000;
+        results[7] = x ^ -1000;
+
+        if (results[0] != 78777) { return 1; }
+        if (results[1] != -76777) { return 2; }
+        if (results[2] != 77777000) { return 3; }
+        if (results[3] != 77) { return 4; }
+        if (results[4] != 777) { return 5; }
+        if (results[5] != 960) { return 6; }
+        if (results[6] != -39) { return 7; }
+        if (results[7] != -76855) { return 8; }
+        return 0;
+    }
+
+    /*
+     * More operations, this time with 8-bit constants.  (x=-55555)
+     */
+    static int lit8Test(int x) {
+
+        int[] results = new int[8];
+
+        /* try to generate op-int/lit8" instructions */
+        results[0] = x + 10;
+        results[1] = 10 - x;
+        results[2] = x * 10;
+        results[3] = x / 10;
+        results[4] = x % 10;
+        results[5] = x & 10;
+        results[6] = x | -10;
+        results[7] = x ^ -10;
+        int minInt = -2147483648;
+        int result = minInt / -1;
+        if (result != minInt) {return 1; }
+        if (results[0] != -55545) {return 2; }
+        if (results[1] != 55565) {return 3; }
+        if (results[2] != -555550) {return 4; }
+        if (results[3] != -5555) {return 5; }
+        if (results[4] != -5) {return 6; }
+        if (results[5] != 8) {return 7; }
+        if (results[6] != -1) {return 8; }
+        if (results[7] != 55563) {return 9; }
+        return 0;
+    }
+
+
+    /*
+     * Shift some data.  (value=0xff00aa01, dist=8)
+     */
+    static int intShiftTest(int value, int dist) {
+        int results[] = new int[4];
+        results[0] = value << dist;
+        results[1] = value >> dist;
+        results[2] = value >>> dist;
+        results[3] = (((value << dist) >> dist) >>> dist) << dist;
+        if (results[0] != 0x00aa0100) {return 1; }
+        if (results[1] != 0xffff00aa) {return 2; }
+        if (results[2] != 0x00ff00aa) {return 3; }
+        if (results[3] != 0xaa00) {return 4; }
+        return 0;
+    }
+
+    /*
+     * We pass in the arguments and return the results so the compiler
+     * doesn't do the math for us.  (x=70000000000, y=-3)
+     */
+    static int longOperTest(long x, long y) {
+        long[] results = new long[10];
+
+        /* this seems to generate "op-long" instructions */
+        results[0] = x + y;
+        results[1] = x - y;
+        results[2] = x * y;
+        results[3] = x * x;
+        results[4] = x / y;
+        results[5] = x % -y;
+        results[6] = x & y;
+        results[7] = x | y;
+        results[8] = x ^ y;
+        /* this seems to generate "op-long/2addr" instructions */
+        results[9] = x + ((((((((x + y) - y) * y) / y) % y) & y) | y) ^ y);
+        /* check this edge case while we're here (div-long/2addr) */
+        long minLong = -9223372036854775808L;
+        long negOne = -results[5];
+        long plusOne = 1;
+        long result = (((minLong + plusOne) - plusOne) / negOne) / negOne;
+        if (result != minLong) { return 1; }
+        if (results[0] != 69999999997L) { return 2; }
+        if (results[1] != 70000000003L) { return 3; }
+        if (results[2] != -210000000000L) { return 4; }
+        if (results[3] != -6833923606740729856L) { return 5; }    // overflow
+        if (results[4] != -23333333333L) { return 6; }
+        if (results[5] != 1) { return 7; }
+        if (results[6] != 70000000000L) { return 8; }
+        if (results[7] != -3) { return 9; }
+        if (results[8] != -70000000003L) { return 10; }
+        if (results[9] != 70000000000L) { return 11; }
+        if (results.length != 10) { return 12; }
+        return 0;
+    }
+
+    /*
+     * Shift some data.  (value=0xd5aa96deff00aa01, dist=16)
+     */
+    static long longShiftTest(long value, int dist) {
+        long results[] = new long[4];
+        results[0] = value << dist;
+        results[1] = value >> dist;
+        results[2] = value >>> dist;
+        results[3] = (((value << dist) >> dist) >>> dist) << dist;
+        if (results[0] != 0x96deff00aa010000L) { return results[0]; }
+        if (results[1] != 0xffffd5aa96deff00L) { return results[1]; }
+        if (results[2] != 0x0000d5aa96deff00L) { return results[2]; }
+        if (results[3] != 0xffff96deff000000L) { return results[3]; }
+        if (results.length != 4) { return 5; }
+
+        return results[0];      // test return-long
+    }
+
+    static int switchTest(int a) {
+        int res = 1234;
+
+        switch (a) {
+            case -1: res = 1; return res;
+            case 0: res = 2; return res;
+            case 1: /*correct*/ break;
+            case 2: res = 3; return res;
+            case 3: res = 4; return res;
+            case 4: res = 5; return res;
+            default: res = 6; return res;
+        }
+        switch (a) {
+            case 3: res = 7; return res;
+            case 4: res = 8; return res;
+            default: /*correct*/ break;
+        }
+
+        a = 0x12345678;
+
+        switch (a) {
+            case 0x12345678: /*correct*/ break;
+            case 0x12345679: res = 9; return res;
+            default: res = 1; return res;
+        }
+        switch (a) {
+            case 57: res = 10; return res;
+            case -6: res = 11; return res;
+            case 0x12345678: /*correct*/ break;
+            case 22: res = 12; return res;
+            case 3: res = 13; return res;
+            default: res = 14; return res;
+        }
+        switch (a) {
+            case -6: res = 15; return res;
+            case 3: res = 16; return res;
+            default: /*correct*/ break;
+        }
+
+        a = -5;
+        switch (a) {
+            case 12: res = 17; return res;
+            case -5: /*correct*/ break;
+            case 0: res = 18; return res;
+            default: res = 19; return res;
+        }
+
+        switch (a) {
+            default: /*correct*/ break;
+        }
+        return res;
+    }
+    /*
+     * Test the integer comparisons in various ways.
+     */
+    static int testIntCompare(int minus, int plus, int plus2, int zero) {
+        int res = 1111;
+
+        if (minus > plus)
+            return 1;
+        if (minus >= plus)
+            return 2;
+        if (plus < minus)
+            return 3;
+        if (plus <= minus)
+            return 4;
+        if (plus == minus)
+            return 5;
+        if (plus != plus2)
+            return 6;
+
+        /* try a branch-taken */
+        if (plus != minus) {
+            res = res;
+        } else {
+            return 7;
+        }
+
+        if (minus > 0)
+            return 8;
+        if (minus >= 0)
+            return 9;
+        if (plus < 0)
+            return 10;
+        if (plus <= 0)
+            return 11;
+        if (plus == 0)
+            return 12;
+        if (zero != 0)
+            return 13;
+
+        if (zero == 0) {
+            res = res;
+        } else {
+            return 14;
+        }
+        return res;
+    }
+
+    /*
+     * Test cmp-long.
+     *
+     * minus=-5, alsoMinus=0xFFFFFFFF00000009, plus=4, alsoPlus=8
+     */
+    static int testLongCompare(long minus, long alsoMinus, long plus,
+                               long alsoPlus) {
+        int res = 2222;
+
+        if (minus > plus)
+            return 2;
+        if (plus < minus)
+            return 3;
+        if (plus == minus)
+            return 4;
+
+        if (plus >= plus+1)
+            return 5;
+        if (minus >= minus+1)
+            return 6;
+
+        /* try a branch-taken */
+        if (plus != minus) {
+            res = res;
+        } else {
+            return 7;
+        }
+
+        /* compare when high words are equal but low words differ */
+        if (plus > alsoPlus)
+            return 8;
+        if (alsoPlus < plus)
+            return 9;
+        if (alsoPlus == plus)
+            return 10;
+
+        /* high words are equal, low words have apparently different signs */
+        if (minus < alsoMinus)      // bug!
+            return 11;
+        if (alsoMinus > minus)
+            return 12;
+        if (alsoMinus == minus)
+            return 13;
+
+        return res;
+    }
+
+    /*
+     * Test cmpl-float and cmpg-float.
+     */
+    static int testFloatCompare(float minus, float plus, float plus2,
+                                float nan) {
+
+        int res = 3333;
+        if (minus > plus)
+            res = 1;
+        if (plus < minus)
+            res = 2;
+        if (plus == minus)
+            res = 3;
+        if (plus != plus2)
+            res = 4;
+
+        if (plus <= nan)
+            res = 5;
+        if (plus >= nan)
+            res = 6;
+        if (minus <= nan)
+            res = 7;
+        if (minus >= nan)
+            res = 8;
+        if (nan >= plus)
+            res = 9;
+        if (nan <= plus)
+            res = 10;
+
+        if (nan == nan)
+            res = 1212;
+
+        return res;
+    }
+
+    static int testDoubleCompare(double minus, double plus, double plus2,
+                                 double nan) {
+
+        int res = 4444;
+
+        if (minus > plus)
+            return 1;
+        if (plus < minus)
+            return 2;
+        if (plus == minus)
+            return 3;
+        if (plus != plus2)
+            return 4;
+
+        if (plus <= nan)
+            return 5;
+        if (plus >= nan)
+            return 6;
+        if (minus <= nan)
+            return 7;
+        if (minus >= nan)
+            return 8;
+        if (nan >= plus)
+            return 9;
+        if (nan <= plus)
+            return 10;
+
+        if (nan == nan)
+            return 11;
+        return res;
+    }
+
+    static int fibonacci(int n) {
+        if (n == 0) {
+            return 0;
+        } else if (n == 1) {
+            return 1;
+        } else {
+            return fibonacci(n - 1) + fibonacci(n - 2);
+        }
+    }
+
+    /*
+      static void throwNullPointerException() {
+      throw new NullPointerException("first throw");
+      }
+
+      static int throwAndCatch() {
+      try {
+      throwNullPointerException();
+      return 1;
+      } catch (NullPointerException npe) {
+      return 0;
+      }
+      }
+    */
+
+    static int manyArgs(int a0, long a1, int a2, long a3, int a4, long a5,
+                        int a6, int a7, double a8, float a9, double a10, short a11, int a12,
+                        char a13, int a14, int a15, byte a16, boolean a17, int a18, int a19,
+                        long a20, long a21, int a22, int a23, int a24, int a25, int a26)
+    {
+        if (a0 != 0) return 0;
+        if (a1 !=  1L) return 1;
+        if (a2 != 2) return 2;
+        if (a3 != 3L) return 3;
+        if (a4 != 4) return 4;
+        if (a5 != 5L) return 5;
+        if (a6 != 6) return 6;
+        if (a7 != 7) return 7;
+        if (a8 != 8.0) return 8;
+        if (a9 !=  9.0f) return 9;
+        if (a10 != 10.0) return 10;
+        if (a11 != (short)11) return 11;
+        if (a12 != 12) return 12;
+        if (a13 != (char)13) return 13;
+        if (a14 != 14) return 14;
+        if (a15 != 15) return 15;
+        if (a16 != (byte)-16) return 16;
+        if (a17 !=  true) return 17;
+        if (a18 != 18) return 18;
+        if (a19 != 19) return 19;
+        if (a20 !=  20L) return 20;
+        if (a21 != 21L) return 21;
+        if (a22 != 22) return 22;
+        if (a23 != 23) return 23;
+        if (a24 != 24) return 24;
+        if (a25 != 25) return 25;
+        if (a26 != 26) return 26;
+        return -1;
+    }
+
+    int virtualCall(int a)
+    {
+        return a * 2;
+    }
+
+    void setFoo(int a)
+    {
+        foo_ = a;
+    }
+
+    int getFoo()
+    {
+        return foo_;
+    }
+
+    static int staticCall(int a)
+    {
+        IntMath foo = new IntMath();
+        return foo.virtualCall(a);
+    }
+
+    static int testIGetPut(int a)
+    {
+        IntMath foo = new IntMath(99);
+        IntMath foo123 = new IntMath();
+        int z  = foo.getFoo();
+        z += a;
+        z += foo123.getFoo();
+        foo.setFoo(z);
+        return foo.getFoo();
+    }
+
+    public static void main(String[] args) {
+        int res = unopTest(38);
+        if (res == 37) {
+            System.out.printf("unopTest PASSED\n");
+        } else {
+            System.out.printf("unopTest FAILED: %d\n", res);
+        }
+        res = shiftTest1();
+        if (res == 0) {
+            System.out.printf("shiftTest1 PASSED\n");
+        } else {
+            System.out.printf("shiftTest1 FAILED: %d\n", res);
+        }
+        res = shiftTest2();
+        if (res == 0) {
+            System.out.printf("shiftTest2 PASSED\n");
+        } else {
+            System.out.printf("shiftTest2 FAILED: %d\n", res);
+        }
+        res = unsignedShiftTest();
+        if (res == 0) {
+            System.out.printf("unsignedShiftTest PASSED\n");
+        } else {
+            System.out.printf("unsignedShiftTest FAILED: %d\n", res);
+        }
+        res = convTest();
+        if (res == 0) {
+            System.out.printf("convTest PASSED\n");
+        } else {
+            System.out.printf("convTest FAILED: %d\n", res);
+        }
+        res = charSubTest();
+        if (res == 0) {
+            System.out.printf("charSubTest PASSED\n");
+        } else {
+            System.out.printf("charSubTest FAILED: %d\n", res);
+        }
+        res = intOperTest(70000, -3);
+        if (res == 0) {
+            System.out.printf("intOperTest PASSED\n");
+        } else {
+            System.out.printf("intOperTest FAILED: %d\n", res);
+        }
+        res = longOperTest(70000000000L, -3L);
+        if (res == 0) {
+            System.out.printf("longOperTest PASSED\n");
+        } else {
+            System.out.printf("longOperTest FAILED: %d\n", res);
+        }
+        long lres = longShiftTest(0xd5aa96deff00aa01L, 16);
+        if (lres == 0x96deff00aa010000L) {
+            System.out.printf("longShiftTest PASSED\n");
+        } else {
+            System.out.printf("longShiftTest FAILED: %d\n", res);
+        }
+
+        res = switchTest(1);
+        if (res == 1234) {
+            System.out.printf("switchTest PASSED\n");
+        } else {
+            System.out.printf("switchTest FAILED: %d\n", res);
+        }
+
+        res = testIntCompare(-5, 4, 4, 0);
+        if (res == 1111) {
+            System.out.printf("testIntCompare PASSED\n");
+        } else {
+            System.out.printf("testIntCompare FAILED: %d\n", res);
+        }
+
+        res = testLongCompare(-5L, -4294967287L, 4L, 8L);
+        if (res == 2222) {
+            System.out.printf("testLongCompare PASSED\n");
+        } else {
+            System.out.printf("testLongCompare FAILED: %d\n", res);
+        }
+
+        res = testFloatCompare(-5.0f, 4.0f, 4.0f, (1.0f/0.0f) / (1.0f/0.0f));
+        if (res == 3333) {
+            System.out.printf("testFloatCompare PASSED\n");
+        } else {
+            System.out.printf("testFloatCompare FAILED: %d\n", res);
+        }
+
+        res = testDoubleCompare(-5.0, 4.0, 4.0, (1.0/0.0) / (1.0/0.0));
+        if (res == 4444) {
+            System.out.printf("testDoubleCompare PASSED\n");
+        } else {
+            System.out.printf("testDoubleCompare FAILED: %d\n", res);
+        }
+
+        res = fibonacci(10);
+        if (res == 55) {
+            System.out.printf("fibonacci PASSED\n");
+        } else {
+            System.out.printf("fibonacci FAILED: %d\n", res);
+        }
+
+        /*
+          res = throwAndCatch();
+          if (res == 0) {
+          System.out.printf("throwAndCatch PASSED\n");
+          } else {
+          System.out.printf("throwAndCatch FAILED: %d\n", res);
+          }
+        */
+
+        res = manyArgs(0, 1L, 2, 3L, 4, 5L, 6, 7, 8.0, 9.0f, 10.0,
+                       (short)11, 12, (char)13, 14, 15, (byte)-16, true, 18,
+                       19, 20L, 21L, 22, 23, 24, 25, 26);
+        if (res == -1) {
+            System.out.printf("manyArgs PASSED\n");
+        } else {
+            System.out.printf("manyArgs FAILED: %d\n", res);
+        }
+
+        res = staticCall(3);
+        if (res == 6) {
+            System.out.printf("virtualCall PASSED\n");
+        } else {
+            System.out.printf("virtualCall FAILED: %d\n", res);
+        }
+
+        res = testIGetPut(111);
+        if (res == 333) {
+            System.out.printf("testGetPut PASSED\n");
+        } else {
+            System.out.printf("testGetPut FAILED: %d\n", res);
+        }
+
+        res = staticFieldTest(404);
+        if (res == 1404) {
+            System.out.printf("staticFieldTest PASSED\n");
+        } else {
+            System.out.printf("staticFieldTest FAILED: %d\n", res);
+        }
+    }
+}
diff --git a/test/IntMath/java/lang/Object.java b/test/IntMath/java/lang/Object.java
new file mode 100644
index 0000000..67e54e3
--- /dev/null
+++ b/test/IntMath/java/lang/Object.java
@@ -0,0 +1,5 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+// TODO: remove this when separate compilation works
+package java.lang;
+public class Object {}
diff --git a/test/Interfaces/Interfaces.java b/test/Interfaces/Interfaces.java
new file mode 100644
index 0000000..0b72e92
--- /dev/null
+++ b/test/Interfaces/Interfaces.java
@@ -0,0 +1,16 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class Interfaces {
+    interface I {
+        public void i();
+    }
+    interface J {
+        public void j1();
+        public void j2();
+    }
+    class A implements I, J {
+        public void i() {};
+        public void j1() {};
+        public void j2() {};
+    }
+}
diff --git a/test/Main/Main.java b/test/Main/Main.java
new file mode 100644
index 0000000..757d513
--- /dev/null
+++ b/test/Main/Main.java
@@ -0,0 +1,6 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class Main {
+    public static void main(String args[]) {
+    }
+}
diff --git a/test/MyClass/MyClass.java b/test/MyClass/MyClass.java
new file mode 100644
index 0000000..7a0ccbc
--- /dev/null
+++ b/test/MyClass/MyClass.java
@@ -0,0 +1,3 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class MyClass {}
diff --git a/test/MyClassNatives/MyClassNatives.java b/test/MyClassNatives/MyClassNatives.java
new file mode 100644
index 0000000..5203e4a
--- /dev/null
+++ b/test/MyClassNatives/MyClassNatives.java
@@ -0,0 +1,11 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class MyClass {
+    native void foo();
+    native int fooI(int x);
+    native int fooII(int x, int y);
+    native double fooDD(double x, double y);
+    native Object fooIOO(int x, Object y, Object z);
+    static native Object fooSIOO(int x, Object y, Object z);
+    static synchronized native Object fooSSIOO(int x, Object y, Object z);
+}
diff --git a/test/Nested/Nested.java b/test/Nested/Nested.java
new file mode 100644
index 0000000..73d9e8a
--- /dev/null
+++ b/test/Nested/Nested.java
@@ -0,0 +1,6 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class Nested {
+    class Inner {
+    }
+}
diff --git a/test/ProtoCompare/ProtoCompare.java b/test/ProtoCompare/ProtoCompare.java
new file mode 100644
index 0000000..988e07a
--- /dev/null
+++ b/test/ProtoCompare/ProtoCompare.java
@@ -0,0 +1,8 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class ProtoCompare {
+    int m1(short x, int y, long z) { return x + y + (int)z; }
+    int m2(short x, int y, long z) { return x + y + (int)z; }
+    int m3(long x, int y, short z) { return (int)x + y + z; }
+    long m4(long x, int y, short z) { return x + y + z; }
+}
diff --git a/test/ProtoCompare2/ProtoCompare2.java b/test/ProtoCompare2/ProtoCompare2.java
new file mode 100644
index 0000000..60d1746
--- /dev/null
+++ b/test/ProtoCompare2/ProtoCompare2.java
@@ -0,0 +1,8 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class ProtoCompare2 {
+    int m1(short x, int y, long z) { return x + y + (int)z; }
+    int m2(short x, int y, long z) { return x + y + (int)z; }
+    int m3(long x, int y, short z) { return (int)x + y + z; }
+    long m4(long x, int y, short z) { return x + y + z; }
+}
diff --git a/test/StaticLeafMethods/StaticLeafMethods.java b/test/StaticLeafMethods/StaticLeafMethods.java
new file mode 100644
index 0000000..72aed85
--- /dev/null
+++ b/test/StaticLeafMethods/StaticLeafMethods.java
@@ -0,0 +1,39 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class StaticLeafMethods {
+    static void nop() {
+    }
+    static byte identity(byte x) {
+        return x;
+    }
+    static int identity(int x) {
+        return x;
+    }
+    static int sum(int a, int b) {
+        return a + b;
+    }
+    static int sum(int a, int b, int c) {
+        return a + b + c;
+    }
+    static int sum(int a, int b, int c, int d) {
+        return a + b + c + d;
+    }
+    static int sum(int a, int b, int c, int d, int e) {
+        return a + b + c + d + e;
+    }
+    static double identity(double x) {
+        return x;
+    }
+    static double sum(double a, double b) {
+        return a + b;
+    }
+    static double sum(double a, double b, double c) {
+        return a + b + c;
+    }
+    static double sum(double a, double b, double c, double d) {
+        return a + b + c + d;
+    }
+    static double sum(double a, double b, double c, double d, double e) {
+        return a + b + c + d + e;
+    }
+}
diff --git a/test/Statics/Statics.java b/test/Statics/Statics.java
new file mode 100644
index 0000000..c38447b
--- /dev/null
+++ b/test/Statics/Statics.java
@@ -0,0 +1,14 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class Statics {
+    static boolean s0 = true;
+    static byte s1 = 5;
+    static char s2 = 'a';
+    static short s3 = (short) 65000;
+    static int s4 = 2000000000;
+    static long s5 = 0x123456789abcdefL;
+    static float s6 = 0.5f;
+    static double s7 = 16777217;
+    static Object s8 = "android";
+    static Object[] s9 = { "a", "b" };
+}
diff --git a/test/XandY/X.java b/test/XandY/X.java
new file mode 100644
index 0000000..7104ff8
--- /dev/null
+++ b/test/XandY/X.java
@@ -0,0 +1,3 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class X {}
diff --git a/test/XandY/Y.java b/test/XandY/Y.java
new file mode 100644
index 0000000..a40c3ec
--- /dev/null
+++ b/test/XandY/Y.java
@@ -0,0 +1,3 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+class Y extends X {}