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