1package org.apache.harmony.regex.tests.java.util.regex;
2
3import junit.framework.TestCase;
4import java.util.regex.*;
5
6/**
7 * TODO Type description
8 *
9 */
10public class SplitTest extends TestCase {
11    public void testSimple() {
12        Pattern p = Pattern.compile("/");
13        String[] results = p.split("have/you/done/it/right");
14        String[] expected = new String[] { "have", "you", "done", "it", "right" };
15        assertArraysEqual(expected, results);
16    }
17
18    public void testEmptySplits() {
19        // Trailing empty matches are removed.
20        assertArraysEqual(new String[0], "hello".split("."));
21        assertArraysEqual(new String[] { "1", "2" }, "1:2:".split(":"));
22        // ...including when that results in an empty result.
23        assertArraysEqual(new String[0], ":".split(":"));
24        // ...but not when limit < 0.
25        assertArraysEqual(new String[] { "1", "2", "" }, "1:2:".split(":", -1));
26
27        // Leading empty matches are retained.
28        assertArraysEqual(new String[] { "", "", "o" }, "hello".split(".."));
29
30        // A separator that doesn't occur in the input gets you the input.
31        assertArraysEqual(new String[] { "hello" }, "hello".split("not-present-in-test"));
32        // ...including when the input is the empty string.
33        // (Perl returns an empty list instead.)
34        assertArraysEqual(new String[] { "" }, "".split("not-present-in-test"));
35        assertArraysEqual(new String[] { "" }, "".split("A?"));
36
37        // The limit argument controls the size of the result.
38        // If l == 0, the result is as long as needed, except trailing empty matches are dropped.
39        // If l < 0, the result is as long as needed, and trailing empty matches are retained.
40        // If l > 0, the result contains the first l matches, plus one string containing the remaining input.
41        // Examples without a trailing separator (and hence without a trailing empty match):
42        assertArraysEqual(new String[] { "a", "b", "c" }, "a,b,c".split(",", 0));
43        assertArraysEqual(new String[] { "a,b,c" }, "a,b,c".split(",", 1));
44        assertArraysEqual(new String[] { "a", "b,c" }, "a,b,c".split(",", 2));
45        assertArraysEqual(new String[] { "a", "b", "c" }, "a,b,c".split(",", 3));
46        assertArraysEqual(new String[] { "a", "b", "c" }, "a,b,c".split(",", Integer.MAX_VALUE));
47        // Examples with a trailing separator (and hence possibly with a trailing empty match):
48        assertArraysEqual(new String[] { "a", "b", "c" }, "a,b,c,".split(",", 0));
49        assertArraysEqual(new String[] { "a,b,c," }, "a,b,c,".split(",", 1));
50        assertArraysEqual(new String[] { "a", "b,c," }, "a,b,c,".split(",", 2));
51        assertArraysEqual(new String[] { "a", "b", "c," }, "a,b,c,".split(",", 3));
52        assertArraysEqual(new String[] { "a", "b", "c", "" }, "a,b,c,".split(",", Integer.MAX_VALUE));
53        assertArraysEqual(new String[] { "a", "b", "c", "" }, "a,b,c,".split(",", -1));
54    }
55
56    private void assertArraysEqual(String[] expected, String[] actual) {
57        assertEquals(expected.length, actual.length);
58        for (int i = 0; i < expected.length; i++) {
59            assertEquals(Integer.toString(i), expected[i], actual[i]);
60        }
61    }
62
63    public void testSplit1() throws PatternSyntaxException {
64        Pattern p = Pattern.compile(" ");
65
66        String input = "poodle zoo";
67        String tokens[];
68
69        tokens = p.split(input, 1);
70        assertEquals(1, tokens.length);
71        assertTrue(tokens[0].equals(input));
72        tokens = p.split(input, 2);
73        assertEquals(2, tokens.length);
74        assertEquals("poodle", tokens[0]);
75        assertEquals("zoo", tokens[1]);
76        tokens = p.split(input, 5);
77        assertEquals(2, tokens.length);
78        assertEquals("poodle", tokens[0]);
79        assertEquals("zoo", tokens[1]);
80        tokens = p.split(input, -2);
81        assertEquals(2, tokens.length);
82        assertEquals("poodle", tokens[0]);
83        assertEquals("zoo", tokens[1]);
84        tokens = p.split(input, 0);
85        assertEquals(2, tokens.length);
86        assertEquals("poodle", tokens[0]);
87        assertEquals("zoo", tokens[1]);
88        tokens = p.split(input);
89        assertEquals(2, tokens.length);
90        assertEquals("poodle", tokens[0]);
91        assertEquals("zoo", tokens[1]);
92
93        p = Pattern.compile("d");
94
95        tokens = p.split(input, 1);
96        assertEquals(1, tokens.length);
97        assertTrue(tokens[0].equals(input));
98        tokens = p.split(input, 2);
99        assertEquals(2, tokens.length);
100        assertEquals("poo", tokens[0]);
101        assertEquals("le zoo", tokens[1]);
102        tokens = p.split(input, 5);
103        assertEquals(2, tokens.length);
104        assertEquals("poo", tokens[0]);
105        assertEquals("le zoo", tokens[1]);
106        tokens = p.split(input, -2);
107        assertEquals(2, tokens.length);
108        assertEquals("poo", tokens[0]);
109        assertEquals("le zoo", tokens[1]);
110        tokens = p.split(input, 0);
111        assertEquals(2, tokens.length);
112        assertEquals("poo", tokens[0]);
113        assertEquals("le zoo", tokens[1]);
114        tokens = p.split(input);
115        assertEquals(2, tokens.length);
116        assertEquals("poo", tokens[0]);
117        assertEquals("le zoo", tokens[1]);
118
119        p = Pattern.compile("o");
120
121        tokens = p.split(input, 1);
122        assertEquals(1, tokens.length);
123        assertTrue(tokens[0].equals(input));
124        tokens = p.split(input, 2);
125        assertEquals(2, tokens.length);
126        assertEquals("p", tokens[0]);
127        assertEquals("odle zoo", tokens[1]);
128        tokens = p.split(input, 5);
129        assertEquals(5, tokens.length);
130        assertEquals("p", tokens[0]);
131        assertTrue(tokens[1].equals(""));
132        assertEquals("dle z", tokens[2]);
133        assertTrue(tokens[3].equals(""));
134        assertTrue(tokens[4].equals(""));
135        tokens = p.split(input, -2);
136        assertEquals(5, tokens.length);
137        assertEquals("p", tokens[0]);
138        assertTrue(tokens[1].equals(""));
139        assertEquals("dle z", tokens[2]);
140        assertTrue(tokens[3].equals(""));
141        assertTrue(tokens[4].equals(""));
142        tokens = p.split(input, 0);
143        assertEquals(3, tokens.length);
144        assertEquals("p", tokens[0]);
145        assertTrue(tokens[1].equals(""));
146        assertEquals("dle z", tokens[2]);
147        tokens = p.split(input);
148        assertEquals(3, tokens.length);
149        assertEquals("p", tokens[0]);
150        assertTrue(tokens[1].equals(""));
151        assertEquals("dle z", tokens[2]);
152    }
153
154    public void testSplit2() {
155        Pattern p = Pattern.compile("");
156        String s[];
157        s = p.split("a", -1);
158        assertEquals(3, s.length);
159        assertEquals("", s[0]);
160        assertEquals("a", s[1]);
161        assertEquals("", s[2]);
162
163        s = p.split("", -1);
164        assertEquals(1, s.length);
165        assertEquals("", s[0]);
166
167        s = p.split("abcd", -1);
168        assertEquals(6, s.length);
169        assertEquals("", s[0]);
170        assertEquals("a", s[1]);
171        assertEquals("b", s[2]);
172        assertEquals("c", s[3]);
173        assertEquals("d", s[4]);
174        assertEquals("", s[5]);
175
176        // Regression test for Android
177        assertEquals("GOOG,23,500".split("|").length, 12);
178    }
179
180
181    public void testSplitSupplementaryWithEmptyString() {
182
183        /*
184         * See http://www.unicode.org/reports/tr18/#Supplementary_Characters
185         * We have to treat text as code points not code units.
186         */
187        Pattern p = Pattern.compile("");
188        String s[];
189        s = p.split("a\ud869\uded6b", -1);
190        assertEquals(5, s.length);
191        assertEquals("", s[0]);
192        assertEquals("a", s[1]);
193        assertEquals("\ud869\uded6", s[2]);
194        assertEquals("b", s[3]);
195        assertEquals("", s[4]);
196    }
197}
198