harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ge...@apache.org
Subject svn commit: r387239 [21/21] - in /incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math: ./ Harmony/ doc/ doc/images/ make/ src/ src/common/ src/common/javasrc/ src/common/javasrc/java/ src/common/javasrc/java/applet/ src/common/javasrc/ja...
Date Mon, 20 Mar 2006 16:31:33 GMT
Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerSubtractTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerSubtractTest.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerSubtractTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerSubtractTest.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,547 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  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.
+ */
+/**
+ * @author Elena Semukhina
+ * @version $Revision: 1.4.6.2 $
+ */
+
+package java.math;
+
+import junit.framework.TestCase;
+import java.math.BigInteger;
+
+/**
+ * Class:  java.math.BigInteger
+ * Method: subtract 
+ */
+public class BigIntegerSubtractTest extends TestCase {
+    /**
+     * Subtract two positive numbers of the same length.
+     * The first is greater.
+     */
+    public void testCase1() {
+        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        int aSign = 1;
+        int bSign = 1;        
+        byte rBytes[] = {9, 18, 27, 36, 45, 54, 63, 9, 18, 27};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract two positive numbers of the same length.
+     * The second is greater.
+     */
+    public void testCase2() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = 1;
+        int bSign = 1;        
+        byte rBytes[] = {-10, -19, -28, -37, -46, -55, -64, -10, -19, -27};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+
+    /**
+     * Subtract two numbers of the same length and different signs.
+     * The first is positive.
+     * The first is greater in absolute value.
+     */
+    public void testCase3() {
+        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        int aSign = 1;
+        int bSign = -1;        
+        byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract two numbers of the same length and different signs.
+     * The first is positive.
+     * The second is greater in absolute value.
+     */
+    public void testCase4() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = 1;
+        int bSign = -1;        
+        byte rBytes[] = {11, 22, 33, 44, 55, 66, 77, 11, 22, 33};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract two negative numbers of the same length.
+     * The first is greater in absolute value.
+     */
+    public void testCase5() {
+        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        int aSign = -1;
+        int bSign = -1;        
+        byte rBytes[] = {-10, -19, -28, -37, -46, -55, -64, -10, -19, -27};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+
+    /**
+     * Subtract two negative numbers of the same length.
+     * The second is greater in absolute value.
+     */
+    public void testCase6() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = -1;
+        int bSign = -1;        
+        byte rBytes[] = {9, 18, 27, 36, 45, 54, 63, 9, 18, 27};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract two numbers of the same length and different signs.
+     * The first is negative.
+     * The first is greater in absolute value.
+     */
+    public void testCase7() {
+        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        int aSign = -1;
+        int bSign = 1;        
+        byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+
+    /**
+     * Subtract two numbers of the same length and different signs.
+     * The first is negative.
+     * The second is greater in absolute value.
+     */
+    public void testCase8() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = -1;
+        int bSign = 1;        
+        byte rBytes[] = {-12, -23, -34, -45, -56, -67, -78, -12, -23, -33};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+    
+    /**
+     * Subtract two positive numbers of different length.
+     * The first is longer.
+     */
+    public void testCase9() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = 1;
+        int bSign = 1;        
+        byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+    
+    /**
+     * Subtract two positive numbers of different length.
+     * The second is longer.
+     */
+    public void testCase10() {
+        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        int aSign = 1;
+        int bSign = 1;        
+        byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+
+    /**
+     * Subtract two numbers of different length and different signs.
+     * The first is positive.
+     * The first is greater in absolute value.
+     */
+    public void testCase11() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = 1;
+        int bSign = -1;        
+        byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract two numbers of the same length and different signs.
+     * The first is positive.
+     * The second is greater in absolute value.
+     */
+    public void testCase12() {
+        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        int aSign = 1;
+        int bSign = -1;        
+        byte rBytes[] = {1, 2, 3, 4, 15, 26, 37, 41, 52, 63, 74, 15, 26, 37};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+    
+    /**
+     * Subtract two numbers of different length and different signs.
+     * The first is negative.
+     * The first is longer.
+     */
+    public void testCase13() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = -1;
+        int bSign = 1;        
+        byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+
+    /**
+     * Subtract two numbers of the same length and different signs.
+     * The first is negative.
+     * The second is longer.
+     */
+    public void testCase14() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = -1;
+        int bSign = 1;        
+        byte rBytes[] = {-2, -3, -4, -5, -16, -27, -38, -42, -53, -64, -75, -16, -27, -37};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+
+    /**
+     * Subtract two negative numbers of different length.
+     * The first is longer.
+     */
+    public void testCase15() {
+        byte aBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        byte bBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        int aSign = -1;
+        int bSign = -1;        
+        byte rBytes[] = {-2, -3, -4, -4, 5, 14, 23, 39, 48, 57, 66, 5, 14, 23};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+}
+    
+    /**
+     * Subtract two negative numbers of different length.
+     * The second is longer.
+     */
+    public void testCase16() {
+        byte aBytes[] = {10, 20, 30, 40, 50, 60, 70, 10, 20, 30};
+        byte bBytes[] = {1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7};
+        int aSign = -1;
+        int bSign = -1;        
+        byte rBytes[] = {1, 2, 3, 3, -6, -15, -24, -40, -49, -58, -67, -6, -15, -23};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+    
+    /**
+     * Subtract two positive equal in absolute value numbers.
+     */
+    public void testCase17() {
+        byte aBytes[] = {-120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        byte bBytes[] = {-120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        byte rBytes[] = {0};
+        int aSign = 1;
+        int bSign = 1;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 0);
+    }
+
+    /**
+     * Subtract zero from a number.
+     * The number is positive.
+     */
+    public void testCase18() {
+        byte aBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        byte bBytes[] = {0};
+        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        int aSign = 1;
+        int bSign = 0;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract a number from zero.
+     * The number is negative.
+     */
+    public void testCase19() {
+        byte aBytes[] = {0};
+        byte bBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        int aSign = 0;
+        int bSign = -1;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract zero from zero.
+     */
+    public void testCase20() {
+        byte aBytes[] = {0};
+        byte bBytes[] = {0};
+        byte rBytes[] = {0};
+        int aSign = 0;
+        int bSign = 0;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 0);
+    }
+    
+    /**
+     * Subtract ZERO from a number.
+     * The number is positive.
+     */
+    public void testCase21() {
+        byte aBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        int aSign = 1;
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = BigInteger.ZERO;
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract a number from ZERO.
+     * The number is negative.
+     */
+    public void testCase22() {
+        byte bBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        byte rBytes[] = {120, 34, 78, -23, -111, 45, 127, 23, 45, -3};
+        int bSign = -1;
+        BigInteger aNumber = BigInteger.ZERO;
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 1);
+    }
+
+    /**
+     * Subtract ZERO from ZERO.
+     */
+    public void testCase23() {
+        byte rBytes[] = {0};
+        BigInteger aNumber = BigInteger.ZERO;
+        BigInteger bNumber = BigInteger.ZERO;
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 0);
+    }
+
+    /**
+     * Subtract ONE from ONE.
+     */
+    public void testCase24() {
+        byte rBytes[] = {0};
+        BigInteger aNumber = BigInteger.ONE;
+        BigInteger bNumber = BigInteger.ONE;
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == 0);
+    }
+
+    /**
+     * Subtract two numbers so that borrow is 1.
+     */
+    public void testCase25() {
+        byte aBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
+        byte bBytes[] = {-128, -128, -128, -128, -128, -128, -128, -128, -128};
+        int aSign = 1;
+        int bSign = 1;        
+        byte rBytes[] = {-128, 127, 127, 127, 127, 127, 127, 127, 127};
+        BigInteger aNumber = new BigInteger(aSign, aBytes);
+        BigInteger bNumber = new BigInteger(bSign, bBytes);
+        BigInteger result = aNumber.subtract(bNumber);
+        byte resBytes[] = new byte[rBytes.length];
+        resBytes = result.toByteArray();
+        for(int i = 0; i < resBytes.length; i++) {
+            assertTrue(resBytes[i] == rBytes[i]);
+        }
+        assertTrue(result.signum() == -1);
+    }
+}
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerToStringTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerToStringTest.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerToStringTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerToStringTest.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,152 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  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.
+ */
+/**
+ * @author Elena Semukhina
+ * @version $Revision: 1.3.6.2 $
+ */
+
+package java.math;
+
+import java.math.BigInteger;
+
+import junit.framework.TestCase;
+
+/**
+ * Class:   java.math.BigInteger
+ * Method: toString(int radix)
+ */
+public class BigIntegerToStringTest extends TestCase {
+    /**
+     * If 36 < radix < 2 it should be set to 10
+     */
+    public void testRadixOutOfRange() {
+        String value = "442429234853876401";
+        int radix = 10;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(45);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test negative number of radix 2
+     */
+    public void testRadix2Neg() {
+        String value = "-101001100010010001001010101110000101010110001010010101010101010101010101010101010101010101010010101";
+        int radix = 2;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test positive number of radix 2
+     */
+    public void testRadix2Pos() {
+        String value = "101000011111000000110101010101010101010001001010101010101010010101010101010000100010010";
+        int radix = 2;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test negative number of radix 10
+     */
+    public void testRadix10Neg() {
+        String value = "-2489756308572364789878394872984";
+        int radix = 16;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test positive number of radix 10
+     */
+    public void testRadix10Pos() {
+        String value = "2387627892347567398736473476";
+        int radix = 16;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test negative number of radix 16
+     */
+    public void testRadix16Neg() {
+        String value = "-287628a883451b800865c67e8d7ff20";
+        int radix = 16;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test positive number of radix 16
+     */
+    public void testRadix16Pos() {
+        String value = "287628a883451b800865c67e8d7ff20";
+        int radix = 16;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test negative number of radix 24
+     */
+    public void testRadix24Neg() {
+        String value = "-287628a88gmn3451b8ijk00865c67e8d7ff20";
+        int radix = 24;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test positive number of radix 24
+     */
+    public void testRadix24Pos() {
+        String value = "287628a883451bg80ijhk0865c67e8d7ff20";
+        int radix = 24;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test negative number of radix 24
+     */
+    public void testRadix36Neg() {
+        String value = "-uhguweut98iu4h3478tq3985pq98yeiuth33485yq4aiuhalai485yiaehasdkr8tywi5uhslei8";
+        int radix = 36;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+
+    /**
+     * test positive number of radix 24
+     */
+    public void testRadix36Pos() {
+        String value = "23895lt45y6vhgliuwhgi45y845htsuerhsi4586ysuerhtsio5y68peruhgsil4568ypeorihtse48y6";
+        int radix = 36;
+        BigInteger aNumber = new BigInteger(value, radix);
+        String result = aNumber.toString(radix);
+        assertTrue(result.equals(value));
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerXorTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerXorTest.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerXorTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/math/BigIntegerXorTest.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,277 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  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.
+ */
+/**
+ * @author Elena Semukhina
+ * @version $Revision: 1.3.6.2 $
+ */
+
+package java.math;
+
+import junit.framework.TestCase;
+import java.math.BigInteger;
+
+/**
+ * Class:  java.math.BigInteger
+ * Method: xor
+ */
+public class BigIntegerXorTest extends TestCase {
+	/**
+     * Xor for zero and a positive number
+     */
+    public void testZeroPos() {
+        String numA = "0";
+        String numB = "27384627835298756289327365";
+        String res = "27384627835298756289327365";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for zero and a negative number
+     */
+    public void testZeroNeg() {
+        String numA = "0";
+        String numB = "-27384627835298756289327365";
+        String res = "-27384627835298756289327365";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for a positive number and zero 
+     */
+    public void testPosZero() {
+        String numA = "27384627835298756289327365";
+        String numB = "0";
+        String res = "27384627835298756289327365";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for a negative number and zero  
+     */
+    public void testNegPos() {
+        String numA = "-27384627835298756289327365";
+        String numB = "0";
+        String res = "-27384627835298756289327365";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for zero and zero
+     */
+    public void testZeroZero() {
+        String numA = "0";
+        String numB = "0";
+        String res = "0";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for zero and one
+     */
+    public void testZeroOne() {
+        String numA = "0";
+        String numB = "1";
+        String res = "1";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for one and one
+     */
+    public void testOneOne() {
+        String numA = "1";
+        String numB = "1";
+        String res = "0";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two positive numbers of the same length
+     */
+    public void testPosPosSameLength() {
+        String numA = "283746278342837476784564875684767";
+        String numB = "293478573489347658763745839457637";
+        String res = "71412358434940908477702819237626";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two positive numbers; the first is longer
+     */
+    public void testPosPosFirstLonger() {
+        String numA = "2837462783428374767845648748973847593874837948575684767";
+        String numB = "293478573489347658763745839457637";
+        String res = "2837462783428374767845615168483972194300564226167553530";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two positive numbers; the first is shorter
+     */
+    public void testPosPosFirstShorter() {
+        String numA = "293478573489347658763745839457637";
+        String numB = "2837462783428374767845648748973847593874837948575684767";
+        String res = "2837462783428374767845615168483972194300564226167553530";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two negative numbers of the same length
+     */
+    public void testNegNegSameLength() {
+        String numA = "-283746278342837476784564875684767";
+        String numB = "-293478573489347658763745839457637";
+        String res = "71412358434940908477702819237626";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two negative numbers; the first is longer
+     */
+    public void testNegNegFirstLonger() {
+        String numA = "-2837462783428374767845648748973847593874837948575684767";
+        String numB = "-293478573489347658763745839457637";
+        String res = "2837462783428374767845615168483972194300564226167553530";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two negative numbers; the first is shorter
+     */
+    public void testNegNegFirstShorter() {
+        String numA = "293478573489347658763745839457637";
+        String numB = "2837462783428374767845648748973847593874837948575684767";
+        String res = "2837462783428374767845615168483972194300564226167553530";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two numbers of different signs and the same length
+     */
+    public void testPosNegSameLength() {
+        String numA = "283746278342837476784564875684767";
+        String numB = "-293478573489347658763745839457637";
+        String res = "-71412358434940908477702819237628";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two numbers of different signs and the same length
+     */
+    public void testNegPosSameLength() {
+        String numA = "-283746278342837476784564875684767";
+        String numB = "293478573489347658763745839457637";
+        String res = "-71412358434940908477702819237628";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for a negative and a positive numbers; the first is longer
+     */
+    public void testNegPosFirstLonger() {
+        String numA = "-2837462783428374767845648748973847593874837948575684767";
+        String numB = "293478573489347658763745839457637";
+        String res = "-2837462783428374767845615168483972194300564226167553532";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for two negative numbers; the first is shorter
+     */
+    public void testNegPosFirstShorter() {
+        String numA = "-293478573489347658763745839457637";
+        String numB = "2837462783428374767845648748973847593874837948575684767";
+        String res = "-2837462783428374767845615168483972194300564226167553532";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for a positive and a negative numbers; the first is longer
+     */
+    public void testPosNegFirstLonger() {
+        String numA = "2837462783428374767845648748973847593874837948575684767";
+        String numB = "-293478573489347658763745839457637";
+        String res = "-2837462783428374767845615168483972194300564226167553532";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+
+    /**
+     * Xor for a positive and a negative number; the first is shorter
+     */
+    public void testPosNegFirstShorter() {
+        String numA = "293478573489347658763745839457637";
+        String numB = "-2837462783428374767845648748973847593874837948575684767";
+        String res = "-2837462783428374767845615168483972194300564226167553532";
+        BigInteger aNumber = new BigInteger(numA);
+        BigInteger bNumber = new BigInteger(numB);
+        BigInteger result = aNumber.xor(bNumber);
+        assertTrue(res.equals(result.toString()));
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/MatcherTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/MatcherTest.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/MatcherTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/MatcherTest.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,608 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  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.
+ */
+
+/**
+ * @author Nikolay A. Kuznetsov
+ * @version $Revision: 1.10.2.2 $
+ */
+package java.util.regex;
+
+import junit.framework.TestCase;
+
+/**
+ * @author Nikolay A. Kuznetsov
+ * @version $Revision: 1.10.2.2 $
+ */
+public class MatcherTest extends TestCase {
+    String[] testPatterns = {
+        "(a|b)*abb",
+        "(1*2*3*4*)*567",
+        "(a|b|c|d)*aab",
+        "(1|2|3|4|5|6|7|8|9|0)(1|2|3|4|5|6|7|8|9|0)*",
+        "(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)*",
+        "(a|b)*(a|b)*A(a|b)*lice.*",
+        "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(a|b|c|d|e|f|g|h|" +
+        "i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)*(1|2|3|4|5|6|7|8|9|0)*|while|for|struct|if|do"
+
+    };
+    
+    String[] groupPatterns = {
+        "(a|b)*aabb",
+        "((a)|b)*aabb",
+        "((a|b)*)a(abb)",
+        "(((a)|(b))*)aabb",
+        "(((a)|(b))*)aa(b)b",
+        "(((a)|(b))*)a(a(b)b)"
+    };
+    
+
+    public void testAppendReplacement() {
+        Pattern pat = Pattern.compile("XX");
+        Matcher m = pat.matcher("Today is XX-XX-XX ...");
+        StringBuffer sb = new StringBuffer();
+        
+        for (int i=0; m.find(); i++) {
+            m.appendReplacement(sb, new Integer(i*10 + i).toString());
+        }
+        m.appendTail(sb);
+        assertEquals("Today is 0-11-22 ...", sb.toString());
+    }
+    
+    public void testAppendReplacementRef() {
+        Pattern p = Pattern.compile("xx (rur|\\$)");
+        Matcher m = p.matcher("xx $ equals to xx rur.");
+        StringBuffer sb = new StringBuffer();
+        for (int i=1; m.find(); i*=30) {
+            String rep = new Integer(i).toString() + " $1";
+            m.appendReplacement(sb, rep);
+        }
+        m.appendTail(sb);
+        assertEquals("1 $ equals to 30 rur.", sb.toString());
+    }
+    
+    public void testReplaceAll() {
+        String input = "aabfooaabfooabfoob";
+        String pattern = "a*b";
+        Pattern pat = Pattern.compile(pattern);
+        Matcher mat = pat.matcher(input);
+        
+        assertEquals("-foo-foo-foo-", mat.replaceAll("-"));
+    }
+
+    /*
+     * Class under test for Matcher reset(CharSequence)
+     */
+    public void testResetCharSequence() {}
+
+    public void testAppendSlashes() {
+        Pattern p = Pattern.compile("\\\\");
+        Matcher m = p.matcher("one\\cat\\two\\cats\\in\\the\\yard");
+        StringBuffer sb = new StringBuffer();
+        while (m.find()) {
+            m.appendReplacement(sb, "\\\\");
+        }
+        m.appendTail(sb);
+        assertEquals("one\\cat\\two\\cats\\in\\the\\yard", sb.toString());
+        
+    }
+
+    public void testReplaceFirst() {
+        String input = "zzzdogzzzdogzzz";
+        String pattern = "dog";
+        Pattern pat = Pattern.compile(pattern);
+        Matcher mat = pat.matcher(input);
+        
+        assertEquals("zzzcatzzzdogzzz", mat.replaceFirst("cat"));
+    }
+
+    public void testPattern() {
+        //test object equals
+        for (int i=0; i<testPatterns.length; i++) {
+            Pattern test = Pattern.compile(testPatterns[i]);
+            assertEquals(test, test.matcher("aaa").pattern());
+        }
+        
+        //compare string representation
+        for (int i=0; i<testPatterns.length; i++) {
+            assertEquals(testPatterns[i], 
+                    Pattern.compile(testPatterns[i]).matcher("aaa").pattern().toString());
+        }
+    }
+
+    /*
+     * Class under test for Matcher reset()
+     */
+    public void testReset() {}
+
+    /*
+     * Class under test for String group(int)
+     */
+    public void testGroupint() {
+        String positiveTestString = "ababababbaaabb";
+        String negativeTestString = "gjhfgdsjfhgcbv";
+        
+        
+        //test IndexOutOfBoundsException
+        ////
+        for (int i=0; i<groupPatterns.length; i++) {
+            Pattern test = Pattern.compile(groupPatterns[i]);
+            Matcher mat = test.matcher(positiveTestString);
+            mat.matches();
+            try {
+                //groupPattern <index + 1> equals to number of groups
+                //of the specified pattern
+                ////
+                mat.group(i + 2);
+                fail("IndexOutBoundsException expected");
+                mat.group(i + 100);
+                fail("IndexOutBoundsException expected");
+                mat.group(-1);
+                fail("IndexOutBoundsException expected");
+                mat.group(-100);
+                fail("IndexOutBoundsException expected");
+            } catch (IndexOutOfBoundsException iobe) {}
+        }
+        
+        String[][] groupResults = {
+                {"a"},
+                {"a", "a"},
+                {"ababababba", "a", "abb"},
+                {"ababababba", "a", "a", "b"},
+                {"ababababba", "a", "a", "b", "b"},
+                {"ababababba", "a", "a", "b", "abb", "b"},
+        };
+        
+        for (int i=0; i<groupPatterns.length; i++) {
+            Pattern test = Pattern.compile(groupPatterns[i]);
+            Matcher mat = test.matcher(positiveTestString);
+            mat.matches();
+            for (int j = 0; j<groupResults[i].length; j++) {
+                assertEquals("i: " + i +" j: " +j, groupResults[i][j], mat.group(j+1));
+            }
+            
+        }
+        
+    }
+
+    public void testGroup() {
+        String positiveTestString = "ababababbaaabb";
+        String negativeTestString = "gjhfgdsjfhgcbv";
+        for (int i=0; i<groupPatterns.length; i++) {
+            Pattern test = Pattern.compile(groupPatterns[i]);
+            Matcher mat = test.matcher(positiveTestString);
+            mat.matches();
+            //test result
+            assertEquals(positiveTestString, mat.group());
+            
+            //test equal to group(0) result
+            assertEquals(mat.group(0), mat.group());
+        }
+        
+        for (int i=0; i<groupPatterns.length; i++) {
+            Pattern test = Pattern.compile(groupPatterns[i]);
+            Matcher mat = test.matcher(negativeTestString);
+            mat.matches();
+            try {
+                mat.group();
+                fail("IllegalStateException expected for <false> matches result");
+            } catch (IllegalStateException ise) {}
+        }
+    }
+    
+    public void testGroupPossessive() {
+        Pattern pat = Pattern.compile("((a)|(b))++c");
+        Matcher mat = pat.matcher("aac");
+        
+        mat.matches();
+        assertEquals("a", mat.group(1));
+    }
+
+    /*
+     * Class under test for boolean find(int)
+     */
+    public void testFindint() {}
+
+    /*
+     * Class under test for int start(int)
+     */
+    public void testStartint() {}
+
+    /*
+     * Class under test for int end(int)
+     */
+    public void testEndint() {}
+
+    public void testMatchesMisc() {
+        String[][] posSeq = {
+              {"abb", "ababb", "abababbababb", "abababbababbabababbbbbabb"},
+              {"213567", "12324567", "1234567", "213213567", "21312312312567", "444444567"},
+              {"abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab"},
+              {"213234567", "3458", "0987654", "7689546432", "0398576", "98432", "5"},
+              {"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 
+               "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+               "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"},
+              {"ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa", "abbbAbbbliceaaa", "Alice"},
+              {"a123", "bnxnvgds156", "for", "while", "if", "struct"}
+              
+        };
+        
+        for (int i=0; i<testPatterns.length; i++) {
+            Pattern pat = Pattern.compile(testPatterns[i]);
+            for (int j=0; j<posSeq[i].length; j++) {
+                Matcher mat = pat.matcher(posSeq[i][j]);
+                assertTrue("Incorrect match: " + testPatterns[i] + " vs " + posSeq[i][j], mat.matches());
+            }
+        }
+    }
+    
+    public void testMatchesQuantifiers() {
+        String[] testPatternsSingles = {"a{5}", "a{2,4}", "a{3,}"};
+        String[] testPatternsMultiple= {"((a)|(b)){1,2}abb", "((a)|(b)){2,4}", "((a)|(b)){3,}"};
+        
+        String[][] stringSingles = {
+            {"aaaaa", "aaa"},
+            {"aa", "a", "aaa", "aaaaaa", "aaaa", "aaaaa"},
+            {"aaa", "a", "aaaa", "aa"},
+        };
+        
+        String[][] stringMultiples = {
+            {"ababb", "aba"},
+            {"ab", "b", "bab", "ababa", "abba", "abababbb"},
+            {"aba", "b", "abaa", "ba"},
+        };
+        
+        for (int i=0; i<testPatternsSingles.length; i++) {
+            Pattern pat = Pattern.compile(testPatternsSingles[i]);
+            for (int j=0; j<stringSingles.length/2; j++) {
+                assertTrue("Match expected, but failed: " 
+                        + pat.pattern() + " : " + stringSingles[i][j], 
+                        pat.matcher(stringSingles[i][j*2]).matches());
+                assertFalse("Match failure expected, but match succeed: " 
+                        + pat.pattern() + " : " + stringSingles[i][j*2+1], 
+                        pat.matcher(stringSingles[i][j*2+1]).matches());
+            }
+        }
+        
+        for (int i=0; i<testPatternsMultiple.length; i++) {
+            Pattern pat = Pattern.compile(testPatternsMultiple[i]);
+            for (int j=0; j<stringMultiples.length/2; j++) {
+                assertTrue("Match expected, but failed: " 
+                        + pat.pattern() + " : " + stringMultiples[i][j], 
+                        pat.matcher(stringMultiples[i][j*2]).matches());
+                assertFalse("Match failure expected, but match succeed: " 
+                        + pat.pattern() + " : " + stringMultiples[i][j*2+1], 
+                        pat.matcher(stringMultiples[i][j*2+1]).matches());
+            }
+        }
+    }
+    
+    public void testQuantVsGroup() {
+        String patternString = "(d{1,3})((a|c)*)(d{1,3})((a|c)*)(d{1,3})";
+        String testString = "dacaacaacaaddaaacaacaaddd";
+        
+        Pattern pat = Pattern.compile(patternString);
+        Matcher mat = pat.matcher(testString);
+        
+        mat.matches();
+        assertEquals("dacaacaacaaddaaacaacaaddd", mat.group());
+        assertEquals("d", mat.group(1));
+        assertEquals("acaacaacaa", mat.group(2));
+        assertEquals("dd", mat.group(4));
+        assertEquals("aaacaacaa", mat.group(5));
+        assertEquals("ddd", mat.group(7));
+    }
+    
+    public void testLookingAt() {}
+
+    /*
+     * Class under test for boolean find()
+     */
+    public void testFind() {
+        String testPattern = "(abb)";
+        String testString = "cccabbabbabbabbabb";
+        Pattern pat = Pattern.compile(testPattern);
+        Matcher mat = pat.matcher(testString);
+        int start = 3;
+        int end =   6;
+        while(mat.find()) {
+            assertEquals(start, mat.start(1));
+            assertEquals(end, mat.end(1));
+            
+            start = end;
+            end += 3;
+        }
+        
+        testPattern = "(\\d{1,3})";
+        testString  = "aaaa123456789045";
+        
+        Pattern pat2 = Pattern.compile(testPattern);
+        Matcher mat2 = pat2.matcher(testString);
+        start = 4;
+        int length = 3;
+        while(mat2.find()) {
+            assertEquals(testString.substring(start, start+length), mat2.group(1));
+            start += length;
+        }
+    }
+    
+    public void testSEOLsymbols() {
+        Pattern pat = Pattern.compile("^a\\(bb\\[$");
+        Matcher mat = pat.matcher("a(bb[");
+        
+        assertTrue(mat.matches());
+    }
+
+    /*
+     * Class under test for int start()
+     */
+    public void testStart() {}
+
+    public void testGroupCount() {
+        for (int i=0; i<groupPatterns.length; i++) {
+            Pattern test = Pattern.compile(groupPatterns[i]);
+            Matcher mat = test.matcher("ababababbaaabb");
+            mat.matches();
+            assertEquals(i+1, mat.groupCount());
+            
+        }
+    }
+    
+    public void testRelactantQuantifiers() {
+        Pattern pat = Pattern.compile("(ab*)*b");
+        Matcher mat = pat.matcher("abbbb");
+        
+        if (mat.matches()) {
+            assertEquals("abbb", mat.group(1));
+        } else {
+            fail("Match expected: (ab*)*b vs abbbb");
+        }
+    }
+    
+    public void testEnhancedFind() {
+        String input = "foob";
+        String pattern = "a*b";
+        Pattern pat = Pattern.compile(pattern);
+        Matcher mat = pat.matcher(input);
+        
+        
+        mat.find();
+        assertEquals("b", mat.group());
+    }
+    
+    public void _testMatchesURI() {
+        final Pattern pat = Pattern.compile("^(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?");
+        Runnable r1 = new Runnable() {
+            public void run() {
+                Matcher mat = pat.matcher("file:/c:/workspace/api/build.win32/classes/META-INF/" +
+                "services/javax.xml.parsers.DocumentBuilderFactory");
+                int k1=1;
+                while (mat.matches()) {}//System.err.println("1: " + mat.group());
+                System.out.println("1: fail");
+            }
+        };
+        
+        Runnable r2 = new Runnable() {
+            public void run() {
+                Matcher mat = pat.matcher("file:/c:/workspace/" +
+                "services/javax.xml.parsers.DocumentBuilderFactory");
+                int k1=1;
+                while (mat.matches()) {}//System.err.println("2: " + mat.group());
+                System.out.println("2: fail");
+            }
+        };
+        
+        Thread t1 = new Thread(r1);
+        Thread t2 = new Thread(r2);
+        
+        t1.start();
+        t2.start();
+        
+        try {
+            t1.join();
+            t2.join();
+        } catch (Exception e) {}
+        
+    }
+    
+    public void _testUnifiedQuantifiers() {
+        //Pattern pat1 = Pattern.compile("\\s+a");
+        Pattern pat2 = Pattern.compile(" *a");
+        
+        Matcher mat = pat2.matcher("      a");
+        
+        System.out.println("unified: " + mat.find());
+    }
+    
+    public void _testCompositeGroupQuantifiers() {
+        Pattern pat = Pattern.compile("(a|b){0,3}abb");
+        Matcher mat = pat.matcher("ababababababababababaab");
+        
+        System.out.println("composite: " + mat.find());
+    }
+    
+    public void testPosCompositeGroup() {
+        String[] posExamples = {"aabbcc", "aacc", "bbaabbcc"};
+        String[] negExamples = {"aabb", "bb", "bbaabb"};
+        Pattern posPat = Pattern.compile("(aa|bb){1,3}+cc");
+        Pattern negPat = Pattern.compile("(aa|bb){1,3}+bb");
+        
+        Matcher mat;
+        for (int i=0; i<posExamples.length; i++) {
+            mat = posPat.matcher(posExamples[i]);
+            assertTrue(mat.matches());
+        }
+        
+        for (int i=0; i<negExamples.length; i++) {
+            mat = negPat.matcher(negExamples[i]);
+            assertFalse(mat.matches());
+        } 
+        
+        assertTrue(Pattern.matches("(aa|bb){1,3}+bb", "aabbaabb"));
+        
+    }
+    
+    public void testPosAltGroup() {
+        String[] posExamples = {"aacc", "bbcc", "cc"};
+        String[] negExamples = {"bb", "aa"};
+        Pattern posPat = Pattern.compile("(aa|bb)?+cc");
+        Pattern negPat = Pattern.compile("(aa|bb)?+bb");
+        
+        Matcher mat;
+        for (int i=0; i<posExamples.length; i++) {
+            mat = posPat.matcher(posExamples[i]);
+            assertTrue(posPat.toString() + " vs: " + posExamples[i], mat.matches());
+        }
+        
+        for (int i=0; i<negExamples.length; i++) {
+            mat = negPat.matcher(negExamples[i]);
+            assertFalse(mat.matches());
+        } 
+        
+        assertTrue(Pattern.matches("(aa|bb)?+bb", "aabb"));
+    }
+    
+    public void testRelCompGroup() {
+        
+        Matcher mat;
+        Pattern pat;
+        String res = "";
+        for (int i=0; i<4; i++) {
+            pat = Pattern.compile("((aa|bb){" + i + ",3}?).*cc");
+            mat = pat.matcher("aaaaaacc");
+            assertTrue(pat.toString() + " vs: " + "aaaaaacc", mat.matches());
+            assertEquals(res, mat.group(1));
+            res += "aa";
+        }
+    }
+    
+    public void testRelAltGroup() {
+        
+        Matcher mat;
+        Pattern pat;
+        
+        pat = Pattern.compile("((aa|bb)??).*cc");
+        mat = pat.matcher("aacc");
+        assertTrue(pat.toString() + " vs: " + "aacc", mat.matches());
+        assertEquals("", mat.group(1));
+        
+        pat = Pattern.compile("((aa|bb)??)cc");
+        mat = pat.matcher("aacc");
+        assertTrue(pat.toString() + " vs: " + "aacc", mat.matches());
+        assertEquals("aa", mat.group(1));
+    }
+    
+    public void testIgnoreCase() {
+        Pattern pat = Pattern.compile("(aa|bb)*", Pattern.CASE_INSENSITIVE);
+        Matcher mat = pat.matcher("aAbb");
+        
+        assertTrue(mat.matches());
+        
+        pat = Pattern.compile("(a|b|c|d|e)*", Pattern.CASE_INSENSITIVE);
+        mat = pat.matcher("aAebbAEaEdebbedEccEdebbedEaedaebEbdCCdbBDcdcdADa");
+        assertTrue(mat.matches());
+        
+        pat = Pattern.compile("[a-e]*", Pattern.CASE_INSENSITIVE);
+        mat = pat.matcher("aAebbAEaEdebbedEccEdebbedEaedaebEbdCCdbBDcdcdADa");
+        assertTrue(mat.matches());
+        
+    }
+    
+    public void testQuoteReplacement() {
+        assertEquals("\\\\aaCC\\$1", Matcher.quoteReplacement("\\aaCC$1"));
+    }
+    
+    
+    public void testOverFlow() {
+        Pattern tp = Pattern.compile("(a*)*");
+        Matcher tm = tp.matcher("aaa");
+        assertTrue(tm.matches()); 
+        assertEquals("", tm.group(1));
+        
+        assertTrue(Pattern.matches("(1+)\\1+", "11"));
+        assertTrue(Pattern.matches("(1+)(2*)\\2+", "11"));
+        
+        Pattern pat = Pattern.compile("(1+)\\1*");
+        Matcher mat = pat.matcher("11");
+        
+        assertTrue(mat.matches());
+        assertEquals("11", mat.group(1));
+        
+        pat = Pattern.compile("((1+)|(2+))(\\2+)");
+        mat = pat.matcher("11");
+        
+        assertTrue(mat.matches());
+        assertEquals("1", mat.group(2));
+        assertEquals("1", mat.group(1));
+        assertEquals("1", mat.group(4));
+        assertEquals(null, mat.group(3));
+        
+        
+    }
+    
+    public void testUnicode() {
+              
+        assertTrue(Pattern.matches("\\x61a", "aa"));
+        assertTrue(Pattern.matches("\\u0061a", "aa"));
+        assertTrue(Pattern.matches("\\0141a", "aa"));
+        assertTrue(Pattern.matches("\\0777", "?7"));
+        
+    }
+    
+    public void testUnicodeCategory() {
+        assertTrue(Pattern.matches("\\p{Ll}", "k")); //Unicode lower case
+        assertTrue(Pattern.matches("\\P{Ll}", "K")); //Unicode non-lower case
+        assertTrue(Pattern.matches("\\p{Lu}", "K")); //Unicode upper case
+        assertTrue(Pattern.matches("\\P{Lu}", "k")); //Unicode non-upper case
+        //combinations
+        assertTrue(Pattern.matches("[\\p{L}&&[^\\p{Lu}]]", "k"));
+        assertTrue(Pattern.matches("[\\p{L}&&[^\\p{Ll}]]", "K"));
+        assertFalse(Pattern.matches("[\\p{L}&&[^\\p{Lu}]]", "K"));
+        assertFalse(Pattern.matches("[\\p{L}&&[^\\p{Ll}]]", "k"));
+        
+        //category/character combinations
+        assertFalse(Pattern.matches("[\\p{L}&&[^a-z]]", "k"));
+        assertTrue(Pattern.matches("[\\p{L}&&[^a-z]]", "K"));
+        
+        assertTrue(Pattern.matches("[\\p{Lu}a-z]", "k"));
+        assertTrue(Pattern.matches("[a-z\\p{Lu}]", "k"));
+        
+        assertFalse(Pattern.matches("[\\p{Lu}a-d]", "k"));
+        assertTrue(Pattern.matches("[a-d\\p{Lu}]", "K"));
+        
+        assertTrue(Pattern.matches("[\\p{L}&&[^\\p{Lu}&&[^K]]]", "K"));
+        assertFalse(Pattern.matches("[\\p{L}&&[^\\p{Lu}&&[^G]]]", "K"));
+        
+    }
+	
+	public void testSplitEmpty() {
+		
+		Pattern pat = Pattern.compile("");
+		String[] s = pat.split("", -1);
+		
+		assertEquals(1, s.length);
+		assertEquals("", s[0]);
+	}
+	
+	public void testFindDollar() {
+		Matcher mat = Pattern.compile("a$").matcher("a\n");
+		assertTrue(mat.find());
+		assertEquals("a", mat.group());
+	}
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(MatcherTest.class);
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/PatternTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/PatternTest.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/PatternTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/test/common/unit/java/util/regex/PatternTest.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,543 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  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.
+ */
+
+/**
+ * @author Nikolay A. Kuznetsov
+ * @version $Revision: 1.12.2.2 $
+ */
+package java.util.regex;
+
+import junit.framework.TestCase;
+
+/**
+ * @author Nikolay A. Kuznetsov
+ * @version $Revision: 1.12.2.2 $
+ */
+public class PatternTest extends TestCase {
+    String[] testPatterns = {
+        "(a|b)*abb",
+        "(1*2*3*4*)*567",
+        "(a|b|c|d)*aab",
+        "(1|2|3|4|5|6|7|8|9|0)(1|2|3|4|5|6|7|8|9|0)*",
+        "(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)*",
+        "(a|b)*(a|b)*A(a|b)*lice.*",
+        "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(a|b|c|d|e|f|g|h|" +
+        "i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)*(1|2|3|4|5|6|7|8|9|0)*|while|for|struct|if|do"
+
+    };
+    
+	/**
+	 * Constructor for PatternTest.
+	 * @param name
+	 */
+	public PatternTest(String name) {
+		super(name);
+	}
+
+	public void testMatcher() {
+	}
+
+	/*
+	 * Class under test for String[] split(CharSequence, int)
+	 */
+	public void testSplitCharSequenceint() {
+	}
+
+	/*
+	 * Class under test for String[] split(CharSequence)
+	 */
+	public void testSplitCharSequence() {
+	}
+
+	public void testPattern() {
+	}
+
+	public void testFlags() {
+	}
+
+	/*
+	 * Class under test for Pattern compile(String, int)
+	 */
+	public void testCompileStringint() {
+	}
+
+	/*
+	 * Class under test for Pattern compile(String)
+	 */
+	public void testQuantCompileNeg() {
+        String[] patterns = {"5{,2}", "{5asd", "{hgdhg", "{5,hjkh", "{,5hdsh", "{5,3shdfkjh}"};
+        for (int i=0; i<patterns.length; i++) { 
+            try {
+                Pattern.compile(patterns[i]);
+                fail("PatternSyntaxException was expected, but compilation succeeds");
+            } catch (PatternSyntaxException pse) {
+                continue;
+            } catch (Throwable e) {
+                fail("PatternSyntaxException was expected, but other one was thrown: " + e);
+            }
+        }
+	}
+    
+    public void testQuantCompilePos() {
+        String[] patterns = {/*"(abc){1,3}",*/ "abc{2,}", "abc{5}"};
+        for (int i=0; i<patterns.length; i++) {
+            Pattern.compile(patterns[i]);
+        }
+    }
+    
+    public void testQuantComposition() {
+        String pattern = "(a{1,3})aab";
+        java.util.regex.Pattern pat = java.util.regex.Pattern.compile(pattern);
+        java.util.regex.Matcher mat = pat.matcher("aaab");
+        mat.matches();
+        mat.start(1);
+        mat.group(1);
+    }
+
+	public void testMatches() {
+        String[][] posSeq = {
+              {"abb", "ababb", "abababbababb", "abababbababbabababbbbbabb"},
+              {"213567", "12324567", "1234567", "213213567", "21312312312567", "444444567"},
+              {"abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab"},
+              {"213234567", "3458", "0987654", "7689546432", "0398576", "98432", "5"},
+              {"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 
+               "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+               "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"},
+              {"ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa", "abbbAbbbliceaaa", "Alice"},
+              {"a123", "bnxnvgds156", "for", "while", "if", "struct"}
+              
+        };
+        
+        for (int i=0; i<testPatterns.length; i++) {
+            for (int j=0; j<posSeq[i].length; j++) {
+                assertTrue("Incorrect match: " + testPatterns[i] + " vs " + 
+                        posSeq[i][j], Pattern.matches(testPatterns[i], posSeq[i][j]));
+            }
+        }
+    }
+    
+    public void testTimeZoneIssue() {
+        Pattern p = Pattern.compile("GMT(\\+|\\-)(\\d+)(:(\\d+))?");
+        Matcher m = p.matcher("GMT-9:45");
+        assertTrue(m.matches());
+        assertEquals("-", m.group(1));
+        assertEquals("9", m.group(2));
+        assertEquals(":45", m.group(3));
+        assertEquals("45", m.group(4));
+    }
+    
+    
+    public void testCompileRanges() {
+        String[] correctTestPatterns = {
+            "[^]*abb]*",
+            "[^a-d[^m-p]]*abb",
+            "[a-d\\d]*abb",
+            "[abc]*abb",
+            "[a-e&&[de]]*abb",
+            "[^abc]*abb",
+            "[a-e&&[^de]]*abb",
+            "[a-z&&[^m-p]]*abb",
+            "[a-d[m-p]]*abb",
+            "[a-zA-Z]*abb",
+            "[+*?]*abb",
+            "[^+*?]*abb"
+        };
+            
+        String[] inputSecuence = {
+            "kkkk",
+            "admpabb",
+            "abcabcd124654abb",
+            "abcabccbacababb",
+            "dededededededeedabb",
+            "gfdhfghgdfghabb",
+            "accabacbcbaabb",
+            "acbvfgtyabb",
+            "adbcacdbmopabcoabb",
+            "jhfkjhaSDFGHJkdfhHNJMjkhfabb",
+            "+*??+*abb",
+            "sdfghjkabb"
+        };
+        
+        Pattern pat;
+        
+        for (int i=0; i<correctTestPatterns.length; i++) {
+            assertTrue("pattern: " + correctTestPatterns[i] 
+                     + " input: " + inputSecuence[i], 
+                     Pattern.matches(correctTestPatterns[i], inputSecuence[i]));
+            
+        }
+        
+        String[] wrongInputSecuence = {
+                "]",
+                "admpkk",
+                "abcabcd124k654abb",
+                "abwcabccbacababb",
+                "abababdeababdeabb",
+                "abcabcacbacbabb",
+                "acdcbecbaabb",
+                "acbotyabb",
+                "adbcaecdbmopabcoabb",
+                "jhfkjhaSDFGHJk;dfhHNJMjkhfabb",
+                "+*?a?+*abb",
+                "sdf+ghjkabb"
+            };
+        
+        for (int i=0; i<correctTestPatterns.length; i++) {
+            assertFalse("pattern: " + correctTestPatterns[i] 
+                     + " input: " + wrongInputSecuence[i], 
+                     Pattern.matches(correctTestPatterns[i], wrongInputSecuence[i]));
+            
+        }
+    }
+    
+    public void testRangesSpecialCases() {
+        String neg_patterns[] = {
+             "[a-&&[b-c]]",
+             "[a-\\w]",
+             "[b-a]",
+             "[]"
+        };
+        
+        for (int i=0; i<neg_patterns.length; i++) {
+            try {
+                Pattern.compile(neg_patterns[i]);
+                fail("PatternSyntaxException was expected: " + neg_patterns[i]);
+            } catch (PatternSyntaxException pse) {}
+        }
+        
+        String pos_patterns[] = {
+            "[-]+", "----",
+            "[a-]+", "a-a-a-a-aa--",
+            "[\\w-a]+", "123-2312--aaa-213",
+            "[a-]]+", "-]]]]]]]]]]]]]]]"
+        };
+        
+        for (int i=0; i<pos_patterns.length; i++) {
+            String pat = pos_patterns[i++];
+            String inp = pos_patterns[i];
+            assertTrue("pattern: " + pat + " input: " + inp, Pattern.matches(pat, inp));
+        }
+    }
+    
+    public void testZeroSymbols() {
+        assertTrue(Pattern.matches("[\0]*abb", "\0\0\0\0\0\0abb"));
+    }
+    
+    public void testEscapes() {
+        Pattern pat = Pattern.compile("\\Q{]()*?");
+        Matcher mat = pat.matcher("{]()*?");
+        
+        assertTrue(mat.matches());
+    }
+    
+    public void testBug181() {
+        Pattern.compile("[\\t-\\r]");
+    }
+    
+    public void _testBug187() {
+        Pattern.compile("|(?idmsux-idmsux)|(?idmsux-idmsux)|[^|\\[-\\0274|\\,-\\\\[^|W\\}\\nq\\x65\\002\\xFE\\05\\06\\00\\x66\\x47i\\,\\xF2\\=\\06\\u0EA4\\x9B\\x3C\\f\\|\\{\\xE5\\05\\r\\u944A\\xCA\\e|\\x19\\04\\x07\\04\\u607B\\023\\0073\\x91Tr\\0150\\x83]]?(?idmsux-idmsux:\\p{Alpha}{7}?)||(?<=[^\\uEC47\\01\\02\\u3421\\a\\f\\a\\013q\\035w\\e])(?<=\\p{Punct}{0,}?)(?=^\\p{Lower})(?!\\b{8,14})(?<![|\\00-\\0146[^|\\04\\01\\04\\060\\f\\u224DO\\x1A\\xC4\\00\\02\\0315\\0351\\u84A8\\xCBt\\xCC\\06|\\0141\\00\\=\\e\\f\\x6B\\0026Tb\\040\\x76xJ&&[\\\\-\\]\\05\\07\\02\\u2DAF\\t\\x9C\\e\\0023\\02\\,X\\e|\\u6058flY\\u954C]]]{5}?)(?<=\\p{Sc}{8}+)[^|\\026-\\u89BA|o\\u6277\\t\\07\\x50&&\\p{Punct}]{8,14}+((?<=^\\p{Punct})|(?idmsux-idmsux)||(?>[\\x3E-\\]])|(?idmsux-idmsux:\\p{Punct})|(?<![\\0111\\0371\\xDF\\u6A49\\07\\u2A4D\\00\\0212\\02Xd-\\xED[^\\a-\\0061|\\0257\\04\\f\\[\\0266\\043\\03\\x2D\\042&&[^\\f-\\]&&\\s]]])|(?>[|\\n\\042\\uB09F\\06\\u0F2B\\uC96D\\x89\\uC166\\xAA|\\04-\\][^|\\a\\|\\rx\
 \04\\uA770\\n\\02\\t\\052\\056\\0274\\|\\=\\07\\e|\\00-\\x1D&&[^\\005\\uB15B\\uCDAC\\n\\x74\\0103\\0147\\uD91B\\n\\062G\\u9B4B\\077\\}\\0324&&[^\\0302\\,\\0221\\04\\u6D16\\04xy\\uD193\\[\\061\\06\\045\\x0F|\\e\\xBB\\f\\u1B52\\023\\u3AD2\\033\\007\\022\\}\\x66\\uA63FJ-\\0304]]]]{0,0})||(?<![^|\\0154U\\u0877\\03\\fy\\n\\|\\0147\\07-\\=[|q\\u69BE\\0243\\rp\\053\\02\\x33I\\u5E39\\u9C40\\052-\\xBC[|\\0064-\\?|\\uFC0C\\x30\\0060\\x45\\\\\\02\\?p\\xD8\\0155\\07\\0367\\04\\uF07B\\000J[^|\\0051-\\{|\\u9E4E\\u7328\\]\\u6AB8\\06\\x71\\a\\]\\e\\|KN\\u06AA\\0000\\063\\u2523&&[\\005\\0277\\x41U\\034\\}R\\u14C7\\u4767\\x09\\n\\054Ev\\0144\\<\\f\\,Q-\\xE4]]]]]{3}+)|(?>^+)|(?![^|\\|\\nJ\\t\\<\\04E\\\\\\t\\01\\\\\\02\\|\\=\\}\\xF3\\uBEC2\\032K\\014\\uCC5F\\072q\\|\\0153\\xD9\\0322\\uC6C8[^\\t\\0342\\x34\\x91\\06\\{\\xF1\\a\\u1710\\?\\xE7\\uC106\\02pF\\<&&[^|\\]\\064\\u381D\\u50CF\\eO&&[^|\\06\\x2F\\04\\045\\032\\u8536W\\0377\\0017|\\x06\\uE5FA\\05\\xD4\\020\\04c\\xFC\\02H\\x0A\\r]]]]+?)(?idms
 ux-idmsux)|(?<![|\\r-\\,&&[I\\t\\r\\0201\\xDB\\e&&[^|\\02\\06\\00\\<\\a\\u7952\\064\\051\\073\\x41\\?n\\040\\0053\\031&&[\\x15-\\|]]]]{8,11}?)(?![^|\\<-\\uA74B\\xFA\\u7CD2\\024\\07n\\<\\x6A\\0042\\uE4FF\\r\\u896B\\[\\=\\042Y&&^\\p{ASCII}]++)|(?<![R-\\|&&[\\a\\0120A\\u6145\\<\\050-d[|\\e-\\uA07C|\\016-\\u80D9]]]{1,}+)|(?idmsux-idmsux)|(?idmsux-idmsux)|(?idmsux-idmsux:\\B{6,}?)|(?<=\\D{5,8}?)|(?>[\\{-\\0207|\\06-\\0276\\p{XDigit}])(?idmsux-idmsux:[^|\\x52\\0012\\]u\\xAD\\0051f\\0142\\\\l\\|\\050\\05\\f\\t\\u7B91\\r\\u7763\\{|h\\0104\\a\\f\\0234\\u2D4F&&^\\P{InGreek}]))");
+    }
+    
+    public void testOrphanQuantifiers() {
+        try {
+            Pattern.compile("+++++");
+            fail("PatternSyntaxException expected");
+        } catch (PatternSyntaxException pse) {
+            System.out.println(pse);
+        } catch (Throwable e) {
+            fail("PatternSyntaxException expected other one was thrown: " + e);
+        }
+    }
+    
+    public void testOrphanQuantifiers2() {
+        try {
+            Pattern pat = Pattern.compile("\\d+*");
+            fail("PatternSyntaxException expected");
+        } catch (PatternSyntaxException pse) {
+        } catch (Throwable e) {
+            fail("PatternSyntaxException expected other one was thrown: " + e);
+        }
+    }
+    
+    public void testBug197() {
+        Object[] vals = {":",  new Integer(2),  new String[] {"boo", "and:foo"}, 
+                     ":",  new Integer(5),  new String[] { "boo", "and", "foo" },
+                     ":", new Integer(-2), new  String[] { "boo", "and", "foo" },
+                     ":", new Integer(3), new  String[] { "boo", "and", "foo" },
+                     ":", new Integer(1), new  String[] { "boo:and:foo" },
+                     "o", new Integer(5), new  String[] { "b", "", ":and:f", "", "" }, 
+                     "o", new Integer(4), new  String[] { "b", "", ":and:f", "o"},
+                     "o", new Integer(-2), new  String[] { "b", "", ":and:f", "", "" }, 
+                     "o", new Integer(0), new  String[] { "b", "", ":and:f" }};
+
+        for (int i=0; i<vals.length/3;) {
+            String[] res = Pattern.compile(vals[i++].toString()).split("boo:and:foo", 
+                    ((Integer)vals[i++]).intValue());
+            String[] expectedRes = (String[])vals[i++];
+            
+            assertEquals(expectedRes.length, res.length);
+            
+            for(int j=0; j<expectedRes.length; j++) {
+                assertEquals(expectedRes[j], res[j]);
+            }
+        }
+    }
+    
+    public void testURIPatterns() {
+        String URI_REGEXP_STR    = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?";
+        String SCHEME_REGEXP_STR = "^[a-zA-Z]{1}[\\w+-.]+$";
+        String REL_URI_REGEXP_STR= "^(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?";
+        String IPV6_REGEXP_STR     = "^[0-9a-fA-F\\:\\.]+(\\%\\w+)?$";
+        String IPV6_REGEXP_STR2    = "^\\[[0-9a-fA-F\\:\\.]+(\\%\\w+)?\\]$";
+        String IPV4_REGEXP_STR     = "^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$";
+        String HOSTNAME_REGEXP_STR = "\\w+[\\w\\-\\.]*";
+        
+        Pattern URI_REGEXP      = Pattern.compile(URI_REGEXP_STR); 
+        Pattern REL_URI_REGEXP  = Pattern.compile(REL_URI_REGEXP_STR); 
+        Pattern SCHEME_REGEXP   = Pattern.compile(SCHEME_REGEXP_STR); 
+        Pattern IPV4_REGEXP     = Pattern.compile(IPV4_REGEXP_STR); 
+        Pattern IPV6_REGEXP     = Pattern.compile(IPV6_REGEXP_STR); 
+        Pattern IPV6_REGEXP2    = Pattern.compile(IPV6_REGEXP_STR2); 
+        Pattern HOSTNAME_REGEXP = Pattern.compile(HOSTNAME_REGEXP_STR);
+        
+    }
+    
+    public void testFindBoundaryCases1() {
+        Pattern pat = Pattern.compile(".*\n");
+        Matcher mat = pat.matcher("a\n");
+        
+        mat.find();
+        assertEquals("a\n", mat.group());
+        
+    }
+    
+    public void testFindBoundaryCases2() {
+        Pattern pat = Pattern.compile(".*A");
+        Matcher mat = pat.matcher("aAa");
+        
+        mat.find();
+        assertEquals("aA", mat.group());
+        
+    }
+    
+    public void testFindBoundaryCases3() {
+        Pattern pat = Pattern.compile(".*A");
+        Matcher mat = pat.matcher("a\naA\n");
+        
+        mat.find();
+        assertEquals("aA", mat.group());
+        
+    }
+    
+    public void testFindBoundaryCases4() {
+        Pattern pat = Pattern.compile("A.*");
+        Matcher mat = pat.matcher("A\n");
+        
+        mat.find();
+        assertEquals("A", mat.group());
+        
+    }
+    
+    public void testFindBoundaryCases5() {
+        Pattern pat = Pattern.compile(".*A.*");
+        Matcher mat = pat.matcher("\nA\naaa\nA\naaAaa\naaaA\n");
+        //Matcher mat = pat.matcher("\nA\n");
+        String[] res = {
+                "A",
+                "A",
+                "aaAaa",
+                "aaaA"
+        };
+        int k=0;
+        for(;mat.find(); k++) {
+            assertEquals(res[k], mat.group());
+        }
+    }
+    
+    public void testFindBoundaryCases6() {
+        String[] res = {
+                "",
+                "a",
+                "",
+                ""
+        };
+        Pattern pat = Pattern.compile(".*");
+        Matcher mat = pat.matcher("\na\n");
+        int k=0;        
+        
+        for(;mat.find();k++){
+            assertEquals(res[k], mat.group());
+        }
+    }
+    
+    public void _testFindBoundaryCases7() {
+        String[] res = {
+                "",
+                "a",
+                "",
+                ""
+        };
+        Pattern pat = Pattern.compile(".*");
+        Matcher mat = pat.matcher("\na\n");
+        int k=0;        
+        
+        for(;mat.find();k++){
+            System.out.println(mat.group());
+            System.out.flush();
+        }
+    }
+    
+    public void testBackReferences() {
+        Pattern pat = Pattern.compile("(\\((\\w*):(.*):(\\2)\\))");
+        Matcher mat = pat.matcher("(start1: word :start1)(start2: word :start2)");
+        int k=1;
+        for (;mat.find();k++) {
+            assertEquals("start" + k, mat.group(2));
+            assertEquals(" word ", mat.group(3));
+            assertEquals("start" + k, mat.group(4));
+            
+        }
+        
+        assertEquals(3, k);
+    }
+    
+    public void _testBackReferences1() {
+        Pattern pat = Pattern.compile("(\\((\\w*):(.*):(\\2)\\))");
+        Matcher mat = pat.matcher("(start1: word :start1)(start2: word :start2)");
+        int k=1;
+        for (;mat.find();k++) {
+            System.out.println(mat.group(2));
+            System.out.println(mat.group(3));
+            System.out.println(mat.group(4));
+            
+        }
+        
+        assertEquals(3, k);
+    }
+    
+    public void testNewLine() {
+        Pattern pat = Pattern.compile("(^$)*\n", Pattern.MULTILINE);
+        Matcher mat = pat.matcher("\r\n\n");
+        int counter = 0;
+        while (mat.find()) counter++;
+        assertEquals(2, counter);
+    }
+    
+    public void testFindGreedy() {
+        Pattern pat = Pattern.compile(".*aaa", Pattern.DOTALL);
+        Matcher mat = pat.matcher("aaaa\naaa\naaaaaa");
+        mat.matches();
+        assertEquals(15, mat.end());
+    }
+    
+    public void testSOLQuant() {
+        Pattern pat = Pattern.compile("$*", Pattern.MULTILINE);
+        Matcher mat = pat.matcher("\n\n");
+        int counter = 0;
+        while(mat.find()) counter++;
+        
+        assertEquals(3, counter);
+    }
+    
+    public void testIllegalEscape() {
+        try {
+            Pattern.compile("\\y");
+            fail("PatternSyntaxException expected");
+        } catch (PatternSyntaxException pse) {
+            
+        } catch (Exception t) {
+            fail("PatternSyntaxException was expected" +
+                    "but other one was thrown: " + t);
+        }
+    }
+    
+    public void testEmptyFamily() {
+        Pattern.compile("\\p{Lower}");
+        String a = "*";
+    }
+    
+    public void testNonCaptConstr() {
+        //Flags
+        Pattern pat = Pattern.compile("(?i)b*(?-i)a*");
+        assertTrue(pat.matcher("bBbBaaaa").matches());
+        assertFalse(pat.matcher("bBbBAaAa").matches());
+        
+        //Non-capturing groups
+        pat = Pattern.compile("(?i:b*)a*");
+        assertTrue(pat.matcher("bBbBaaaa").matches());
+        assertFalse(pat.matcher("bBbBAaAa").matches());
+        
+        pat = Pattern
+        //             1                        2               3         4      5        6        7       8                 9                   10        11
+        .compile("(?:-|(-?\\d+\\d\\d\\d))?(?:-|-(\\d\\d))?(?:-|-(\\d\\d))?(T)?(?:(\\d\\d):(\\d\\d):(\\d\\d)(\\.\\d+)?)?(?:(?:((?:\\+|\\-)\\d\\d):(\\d\\d))|(Z))?");
+        Matcher mat = pat.matcher("-1234-21-31T41:51:61.789+71:81");
+        assertTrue(mat.matches());
+        assertEquals("-1234", mat.group(1));
+        assertEquals("21", mat.group(2));
+        assertEquals("31", mat.group(3));
+        assertEquals("T", mat.group(4));
+        assertEquals("41", mat.group(5));
+        assertEquals("51", mat.group(6));
+        assertEquals("61", mat.group(7));
+        assertEquals(".789", mat.group(8));
+        assertEquals("+71", mat.group(9));
+        assertEquals("81", mat.group(10));
+        
+        //positive lookahead
+        pat = Pattern.compile(".*\\.(?=log$).*$");
+        assertTrue(pat.matcher("a.b.c.log").matches());
+        assertFalse(pat.matcher("a.b.c.log.").matches());
+        
+        //negative lookahead
+        pat = Pattern.compile(".*\\.(?!log$).*$");
+        assertFalse(pat.matcher("abc.log").matches());
+        assertTrue(pat.matcher("abc.logg").matches());
+        
+        //positive lookbehind
+        pat = Pattern.compile(".*(?<=abc)\\.log$");
+        assertFalse(pat.matcher("cde.log").matches());
+        assertTrue(pat.matcher("abc.log").matches());
+        
+        //negative lookbehind
+        pat = Pattern.compile(".*(?<!abc)\\.log$");
+        assertTrue(pat.matcher("cde.log").matches());
+        assertFalse(pat.matcher("abc.log").matches());
+        
+        //atomic group
+        pat = Pattern.compile("(?>a*)abb");
+        assertFalse(pat.matcher("aaabb").matches());
+        pat = Pattern.compile("(?>a*)bb");
+        assertTrue(pat.matcher("aaabb").matches());
+        
+        pat = Pattern.compile("(?>a|aa)aabb");
+        assertTrue(pat.matcher("aaabb").matches());
+        pat = Pattern.compile("(?>aa|a)aabb");
+        assertFalse(pat.matcher("aaabb").matches());
+        
+        //quantifiers over look aheads
+        pat = Pattern.compile(".*(?<=abc)*\\.log$");
+        assertTrue(pat.matcher("cde.log").matches());
+        pat = Pattern.compile(".*(?<=abc)+\\.log$");
+        assertFalse(pat.matcher("cde.log").matches());
+        
+    }
+    
+    
+    
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(PatternTest.class);
+    }
+}



Mime
View raw message