Regression tests

Create regression tests for parseInt with radix and add failing
regression tests for parseInt and parseInt with radix marked KNOWNBUG
(see issue #664 which is about making them parse).

Author: Owen Jones

regression/strings-smoke-tests/java_parseint/test.desc

@@ -3,6 +3,5 @@ test_parseint.class
 --refine-strings
 ^EXIT=10$
 ^SIGNAL=0$
-^\[.*assertion.1\].* line 7.* SUCCESS$
-^\[.*assertion.2\].* line 8.* FAILURE$
---
+^\[.*assertion.1\].* line 8.* SUCCESS$
+^\[.*assertion.2\].* line 9.* FAILURE$

regression/strings-smoke-tests/java_parseint/test_parseint.class

@@ -1,10 +1,12 @@
 public class test_parseint
 {
-   public static void main(String[] argv)
-   {
-      String twelve = new String("12");
-      int parsed = Integer.parseInt(twelve);
-      assert(parsed == 12);
-      assert(parsed != 12);
-   }
+    public static void main(String[] args)
+    {
+        if (args.length == 1) {
+            String twelve = new String("12");
+            int parsed1 = Integer.parseInt(twelve);
+            assert(parsed1 == 12);
+            assert(parsed1 != 12);
+        }
+    }
 }

regression/strings-smoke-tests/java_parseint/test_parseint.java

@@ -0,0 +1,12 @@
+KNOWNBUG
+test_parseint.class
+--refine-strings
+^EXIT=10$
+^SIGNAL=0$
+^\[.*assertion.1\].* line 9.* SUCCESS$
+^\[.*assertion.2\].* line 10.* FAILURE$
+^\[.*assertion.3\].* line 17.* SUCCESS$
+^\[.*assertion.4\].* line 18.* FAILURE$
+--
+--
+Issue #664 is about turning these tests on

regression/strings-smoke-tests/java_parseint_knownbug/test.desc

@@ -0,0 +1,21 @@
+public class test_parseint
+{
+    public static void main(String[] args)
+    {
+        if (args.length == 2) {
+            // 2^31-1, max value of Integer
+            String max_int = new String("2147483647");
+            int parsed2 = Integer.parseInt(max_int);
+            assert(parsed2 == 2147483647);
+            assert(parsed2 != 2147483647);
+        }
+        else if (args.length == 3) {
+            // -2^31, min value of Integer, and longest string we could have without
+            // leading zeroes
+            String min_int = new String("-2147483648");
+            int parsed3 = Integer.parseInt(min_int);
+            assert(parsed3 == -2147483648);
+            assert(parsed3 != -2147483648);
+        }
+    }
+}

regression/strings-smoke-tests/java_parseint_knownbug/test_parseint.class

@@ -0,0 +1,16 @@
+CORE
+test_parseint_with_radix.class
+--refine-strings
+^EXIT=10$
+^SIGNAL=0$
+^\[.*assertion.1\].* line 8.* SUCCESS$
+^\[.*assertion.2\].* line 9.* FAILURE$
+^\[.*assertion.3\].* line 14.* SUCCESS$
+^\[.*assertion.4\].* line 15.* FAILURE$
+^\[.*assertion.5\].* line 20.* SUCCESS$
+^\[.*assertion.6\].* line 21.* FAILURE$
+^\[.*assertion.7\].* line 26.* SUCCESS$
+^\[.*assertion.8\].* line 27.* FAILURE$
+^\[.*assertion.9\].* line 32.* SUCCESS$
+^\[.*assertion.10\].* line 33.* FAILURE$
+--

regression/strings-smoke-tests/java_parseint_knownbug/test_parseint.java

@@ -0,0 +1,36 @@
+public class test_parseint_with_radix
+{
+    public static void main(String[] args)
+    {
+        if (args.length == 1) {
+            String str1 = new String("F");
+            int parsed1 = Integer.parseInt(str1, 16);
+            assert(parsed1 == 15);
+            assert(parsed1 != 15);
+        }
+        else if (args.length == 2) {
+            String str2 = new String("123");
+            int parsed2 = Integer.parseInt(str2, 10);
+            assert(parsed2 == 123);
+            assert(parsed2 != 123);
+        }
+        else if (args.length == 3) {
+            String str3 = new String("77");
+            int parsed3 = Integer.parseInt(str3, 8);
+            assert(parsed3 == 63);
+            assert(parsed3 != 63);
+        }
+        else if (args.length == 4) {
+            String str4 = new String("-101");
+            int parsed4 = Integer.parseInt(str4, 2);
+            assert(parsed4 == -5);
+            assert(parsed4 != -5);
+        }
+        else if (args.length == 5) {
+            String str5 = new String("00aB");
+            int parsed5 = Integer.parseInt(str5, 16);
+            assert(parsed5 == 171);
+            assert(parsed5 != 171);
+        }
+    }
+}

regression/strings-smoke-tests/java_parseint_with_radix/test.desc

@@ -0,0 +1,12 @@
+KNOWNBUG
+test_parseint_with_radix.class
+--refine-strings
+^EXIT=10$
+^SIGNAL=0$
+^\[.*assertion.1\].* line 9.* SUCCESS$
+^\[.*assertion.2\].* line 10.* FAILURE$
+^\[.*assertion.3\].* line 16.* SUCCESS$
+^\[.*assertion.4\].* line 17.* FAILURE$
+--
+--
+Issue #664 is about turning these tests on

regression/strings-smoke-tests/java_parseint_with_radix/test_parseint_with_radix.class

@@ -0,0 +1,20 @@
+public class test_parseint_with_radix
+{
+    public static void main(String[] args)
+    {
+        if (args.length == 1) {
+            // 2^31-1, max value of Integer
+            String str1 = new String("7FFFFFFF");
+            int parsed1 = Integer.parseInt(str1, 16);
+            assert(parsed1 == 2147483647);
+            assert(parsed1 != 2147483647);
+        }
+        else if (args.length == 2) {
+            // -2^31, min value of Integer, and longest string we could have
+            String str2 = new String("-100000000000000000000000000000000");
+            int parsed2 = Integer.parseInt(str2, 2);
+            assert(parsed2 == -2147483648);
+            assert(parsed2 != -2147483648);
+        }
+   }
+}