SplitTest.java revision f6c387128427e121477c1b32ad35cdcaa5101ba3 
1package org.apache.harmony.regex.tests.java.util.regex;
2
3import dalvik.annotation.TestTargetClass;
4import dalvik.annotation.TestTargets;
5import dalvik.annotation.TestTargetNew;
6import dalvik.annotation.TestLevel;
7
8import junit.framework.TestCase;
9import java.util.regex.*;
10
11@TestTargetClass(java.util.regex.Pattern.class)
12/**
13 * TODO Type description
14 *
15 */
16public class SplitTest extends TestCase {
17    @TestTargets({
18        @TestTargetNew(
19            level = TestLevel.PARTIAL_COMPLETE,
20            notes = "Verifies the basic functionality of split(java.lang.CharSequence) & compile(java.lang.String)methods.",
21            method = "split",
22            args = {java.lang.CharSequence.class}
23        ),
24        @TestTargetNew(
25            level = TestLevel.PARTIAL_COMPLETE,
26            notes = "Verifies the basic functionality of split(java.lang.CharSequence) & compile(java.lang.String)methods.",
27            method = "compile",
28            args = {java.lang.String.class}
29        )
30    })
31    public void testSimple() {
32        Pattern p = Pattern.compile("/");
33        String[] results = p.split("have/you/done/it/right");
34        String[] expected = new String[] { "have", "you", "done", "it", "right" };
35        assertEquals(expected.length, results.length);
36        for (int i = 0; i < expected.length; i++) {
37            assertEquals(results[i], expected[i]);
38        }
39    }
40
41    @TestTargetNew(
42        level = TestLevel.PARTIAL_COMPLETE,
43        notes = "Verifies the functionality of split(java.lang.CharSequence). Test uses not empty pattern.",
44        method = "split",
45        args = {java.lang.CharSequence.class, int.class}
46    )
47    public void testSplit1() throws PatternSyntaxException {
48        Pattern p = Pattern.compile(" ");
49
50        String input = "poodle zoo";
51        String tokens[];
52
53        tokens = p.split(input, 1);
54        assertEquals(1, tokens.length);
55        assertTrue(tokens[0].equals(input));
56        tokens = p.split(input, 2);
57        assertEquals(2, tokens.length);
58        assertEquals("poodle", tokens[0]);
59        assertEquals("zoo", tokens[1]);
60        tokens = p.split(input, 5);
61        assertEquals(2, tokens.length);
62        assertEquals("poodle", tokens[0]);
63        assertEquals("zoo", tokens[1]);
64        tokens = p.split(input, -2);
65        assertEquals(2, tokens.length);
66        assertEquals("poodle", tokens[0]);
67        assertEquals("zoo", tokens[1]);
68        tokens = p.split(input, 0);
69        assertEquals(2, tokens.length);
70        assertEquals("poodle", tokens[0]);
71        assertEquals("zoo", tokens[1]);
72        tokens = p.split(input);
73        assertEquals(2, tokens.length);
74        assertEquals("poodle", tokens[0]);
75        assertEquals("zoo", tokens[1]);
76
77        p = Pattern.compile("d");
78
79        tokens = p.split(input, 1);
80        assertEquals(1, tokens.length);
81        assertTrue(tokens[0].equals(input));
82        tokens = p.split(input, 2);
83        assertEquals(2, tokens.length);
84        assertEquals("poo", tokens[0]);
85        assertEquals("le zoo", tokens[1]);
86        tokens = p.split(input, 5);
87        assertEquals(2, tokens.length);
88        assertEquals("poo", tokens[0]);
89        assertEquals("le zoo", tokens[1]);
90        tokens = p.split(input, -2);
91        assertEquals(2, tokens.length);
92        assertEquals("poo", tokens[0]);
93        assertEquals("le zoo", tokens[1]);
94        tokens = p.split(input, 0);
95        assertEquals(2, tokens.length);
96        assertEquals("poo", tokens[0]);
97        assertEquals("le zoo", tokens[1]);
98        tokens = p.split(input);
99        assertEquals(2, tokens.length);
100        assertEquals("poo", tokens[0]);
101        assertEquals("le zoo", tokens[1]);
102
103        p = Pattern.compile("o");
104
105        tokens = p.split(input, 1);
106        assertEquals(1, tokens.length);
107        assertTrue(tokens[0].equals(input));
108        tokens = p.split(input, 2);
109        assertEquals(2, tokens.length);
110        assertEquals("p", tokens[0]);
111        assertEquals("odle zoo", tokens[1]);
112        tokens = p.split(input, 5);
113        assertEquals(5, tokens.length);
114        assertEquals("p", tokens[0]);
115        assertTrue(tokens[1].equals(""));
116        assertEquals("dle z", tokens[2]);
117        assertTrue(tokens[3].equals(""));
118        assertTrue(tokens[4].equals(""));
119        tokens = p.split(input, -2);
120        assertEquals(5, tokens.length);
121        assertEquals("p", tokens[0]);
122        assertTrue(tokens[1].equals(""));
123        assertEquals("dle z", tokens[2]);
124        assertTrue(tokens[3].equals(""));
125        assertTrue(tokens[4].equals(""));
126        tokens = p.split(input, 0);
127        assertEquals(3, tokens.length);
128        assertEquals("p", tokens[0]);
129        assertTrue(tokens[1].equals(""));
130        assertEquals("dle z", tokens[2]);
131        tokens = p.split(input);
132        assertEquals(3, tokens.length);
133        assertEquals("p", tokens[0]);
134        assertTrue(tokens[1].equals(""));
135        assertEquals("dle z", tokens[2]);
136    }
137
138    @TestTargetNew(
139        level = TestLevel.PARTIAL_COMPLETE,
140        notes = "Verifies the functionality of split(java.lang.CharSequence). Test uses empty pattern.",
141        method = "split",
142        args = {java.lang.CharSequence.class, int.class}
143    )
144    public void testSplit2() {
145        Pattern p = Pattern.compile("");
146        String s[];
147        s = p.split("a", -1);
148        assertEquals(3, s.length);
149        assertEquals("", s[0]);
150        assertEquals("a", s[1]);
151        assertEquals("", s[2]);
152
153        s = p.split("", -1);
154        assertEquals(1, s.length);
155        assertEquals("", s[0]);
156
157        s = p.split("abcd", -1);
158        assertEquals(6, s.length);
159        assertEquals("", s[0]);
160        assertEquals("a", s[1]);
161        assertEquals("b", s[2]);
162        assertEquals("c", s[3]);
163        assertEquals("d", s[4]);
164        assertEquals("", s[5]);
165
166        // Regression test for Android
167        assertEquals("GOOG,23,500".split("|").length, 12);
168    }
169
170
171    @TestTargets({
172        @TestTargetNew(
173            level = TestLevel.PARTIAL_COMPLETE,
174            notes = "Verifies the functionality of split(java.lang.CharSequence) & compile(java.lang.String, int) methods. Test uses empty pattern and supplementary chars.",
175            method = "split",
176            args = {java.lang.CharSequence.class, int.class}
177        ),
178        @TestTargetNew(
179            level = TestLevel.PARTIAL_COMPLETE,
180            notes = "Verifies the functionality of split(java.lang.CharSequence) & compile(java.lang.String, int) methods. Test uses empty pattern and supplementary chars.",
181            method = "compile",
182            args = {java.lang.String.class}
183        )
184    })
185    public void testSplitSupplementaryWithEmptyString() {
186
187        /*
188         * See http://www.unicode.org/reports/tr18/#Supplementary_Characters
189         * We have to treat text as code points not code units.
190         */
191        Pattern p = Pattern.compile("");
192        String s[];
193        s = p.split("a\ud869\uded6b", -1);
194        assertEquals(5, s.length);
195        assertEquals("", s[0]);
196        assertEquals("a", s[1]);
197        assertEquals("\ud869\uded6", s[2]);
198        assertEquals("b", s[3]);
199        assertEquals("", s[4]);
200    }
201}
202