1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package org.apache.harmony.tests.java.util;
19
20import java.util.Arrays;
21import java.util.Comparator;
22import java.util.HashSet;
23import java.util.Iterator;
24import java.util.Set;
25import java.util.SortedSet;
26import java.util.TreeSet;
27
28public class TreeSetTest extends junit.framework.TestCase {
29
30    public static class ReversedIntegerComparator implements Comparator {
31        public int compare(Object o1, Object o2) {
32            return -(((Integer) o1).compareTo((Integer) o2));
33        }
34
35        public boolean equals(Object o1, Object o2) {
36            return ((Integer) o1).compareTo((Integer) o2) == 0;
37        }
38    }
39
40    TreeSet ts;
41
42    Object objArray[] = new Object[1000];
43
44    /**
45     * java.util.TreeSet#TreeSet()
46     */
47    public void test_Constructor() {
48        // Test for method java.util.TreeSet()
49        assertTrue("Did not construct correct TreeSet", new TreeSet().isEmpty());
50    }
51
52    /**
53     * java.util.TreeSet#TreeSet(java.util.Collection)
54     */
55    public void test_ConstructorLjava_util_Collection() {
56        // Test for method java.util.TreeSet(java.util.Collection)
57        TreeSet myTreeSet = new TreeSet(Arrays.asList(objArray));
58        assertTrue("TreeSet incorrect size",
59                myTreeSet.size() == objArray.length);
60        for (int counter = 0; counter < objArray.length; counter++)
61            assertTrue("TreeSet does not contain correct elements", myTreeSet
62                    .contains(objArray[counter]));
63    }
64
65    /**
66     * java.util.TreeSet#TreeSet(java.util.Comparator)
67     */
68    public void test_ConstructorLjava_util_Comparator() {
69        // Test for method java.util.TreeSet(java.util.Comparator)
70        TreeSet myTreeSet = new TreeSet(new ReversedIntegerComparator());
71        assertTrue("Did not construct correct TreeSet", myTreeSet.isEmpty());
72        myTreeSet.add(new Integer(1));
73        myTreeSet.add(new Integer(2));
74        assertTrue(
75                "Answered incorrect first element--did not use custom comparator ",
76                myTreeSet.first().equals(new Integer(2)));
77        assertTrue(
78                "Answered incorrect last element--did not use custom comparator ",
79                myTreeSet.last().equals(new Integer(1)));
80    }
81
82    /**
83     * java.util.TreeSet#TreeSet(java.util.SortedSet)
84     */
85    public void test_ConstructorLjava_util_SortedSet() {
86        // Test for method java.util.TreeSet(java.util.SortedSet)
87        ReversedIntegerComparator comp = new ReversedIntegerComparator();
88        TreeSet myTreeSet = new TreeSet(comp);
89        for (int i = 0; i < objArray.length; i++)
90            myTreeSet.add(objArray[i]);
91        TreeSet anotherTreeSet = new TreeSet(myTreeSet);
92        assertTrue("TreeSet is not correct size",
93                anotherTreeSet.size() == objArray.length);
94        for (int counter = 0; counter < objArray.length; counter++)
95            assertTrue("TreeSet does not contain correct elements",
96                    anotherTreeSet.contains(objArray[counter]));
97        assertTrue("TreeSet does not answer correct comparator", anotherTreeSet
98                .comparator() == comp);
99        assertTrue("TreeSet does not use comparator",
100                anotherTreeSet.first() == objArray[objArray.length - 1]);
101    }
102
103    /**
104     * java.util.TreeSet#add(java.lang.Object)
105     */
106    public void test_addLjava_lang_Object() {
107        // Test for method boolean java.util.TreeSet.add(java.lang.Object)
108        ts.add(new Integer(-8));
109        assertTrue("Failed to add Object", ts.contains(new Integer(-8)));
110        ts.add(objArray[0]);
111        assertTrue("Added existing element", ts.size() == objArray.length + 1);
112
113    }
114
115    /**
116     * java.util.TreeSet#addAll(java.util.Collection)
117     */
118    public void test_addAllLjava_util_Collection() {
119        // Test for method boolean
120        // java.util.TreeSet.addAll(java.util.Collection)
121        TreeSet s = new TreeSet();
122        s.addAll(ts);
123        assertTrue("Incorrect size after add", s.size() == ts.size());
124        Iterator i = ts.iterator();
125        while (i.hasNext())
126            assertTrue("Returned incorrect set", s.contains(i.next()));
127
128    }
129
130    /**
131     * java.util.TreeSet#clear()
132     */
133    public void test_clear() {
134        // Test for method void java.util.TreeSet.clear()
135        ts.clear();
136        assertEquals("Returned non-zero size after clear", 0, ts.size());
137        assertTrue("Found element in cleared set", !ts.contains(objArray[0]));
138    }
139
140    /**
141     * java.util.TreeSet#clone()
142     */
143    public void test_clone() {
144        // Test for method java.lang.Object java.util.TreeSet.clone()
145        TreeSet s = (TreeSet) ts.clone();
146        Iterator i = ts.iterator();
147        while (i.hasNext())
148            assertTrue("Clone failed to copy all elements", s
149                    .contains(i.next()));
150    }
151
152    /**
153     * java.util.TreeSet#comparator()
154     */
155    public void test_comparator() {
156        // Test for method java.util.Comparator java.util.TreeSet.comparator()
157        ReversedIntegerComparator comp = new ReversedIntegerComparator();
158        TreeSet myTreeSet = new TreeSet(comp);
159        assertTrue("Answered incorrect comparator",
160                myTreeSet.comparator() == comp);
161    }
162
163    /**
164     * java.util.TreeSet#contains(java.lang.Object)
165     */
166    public void test_containsLjava_lang_Object() {
167        // Test for method boolean java.util.TreeSet.contains(java.lang.Object)
168        assertTrue("Returned false for valid Object", ts
169                .contains(objArray[objArray.length / 2]));
170        assertTrue("Returned true for invalid Object", !ts
171                .contains(new Integer(-9)));
172        try {
173            ts.contains(new Object());
174        } catch (ClassCastException e) {
175            // Correct
176            return;
177        }
178        fail("Failed to throw exception when passed invalid element");
179
180    }
181
182    /**
183     * java.util.TreeSet#first()
184     */
185    public void test_first() {
186        // Test for method java.lang.Object java.util.TreeSet.first()
187        assertTrue("Returned incorrect first element",
188                ts.first() == objArray[0]);
189    }
190
191    /**
192     * java.util.TreeSet#headSet(java.lang.Object)
193     */
194    public void test_headSetLjava_lang_Object() {
195        // Test for method java.util.SortedSet
196        // java.util.TreeSet.headSet(java.lang.Object)
197        Set s = ts.headSet(new Integer(100));
198        assertEquals("Returned set of incorrect size", 100, s.size());
199        for (int i = 0; i < 100; i++)
200            assertTrue("Returned incorrect set", s.contains(objArray[i]));
201    }
202
203    /**
204     * java.util.TreeSet#isEmpty()
205     */
206    public void test_isEmpty() {
207        // Test for method boolean java.util.TreeSet.isEmpty()
208        assertTrue("Empty set returned false", new TreeSet().isEmpty());
209        assertTrue("Non-Empty returned true", !ts.isEmpty());
210    }
211
212    /**
213     * java.util.TreeSet#iterator()
214     */
215    public void test_iterator() {
216        // Test for method java.util.Iterator java.util.TreeSet.iterator()
217        TreeSet s = new TreeSet();
218        s.addAll(ts);
219        Iterator i = ts.iterator();
220        Set as = new HashSet(Arrays.asList(objArray));
221        while (i.hasNext())
222            as.remove(i.next());
223        assertEquals("Returned incorrect iterator", 0, as.size());
224
225    }
226
227    /**
228     * java.util.TreeSet#last()
229     */
230    public void test_last() {
231        // Test for method java.lang.Object java.util.TreeSet.last()
232        assertTrue("Returned incorrect last element",
233                ts.last() == objArray[objArray.length - 1]);
234    }
235
236    /**
237     * java.util.TreeSet#remove(java.lang.Object)
238     */
239    public void test_removeLjava_lang_Object() {
240        // Test for method boolean java.util.TreeSet.remove(java.lang.Object)
241        ts.remove(objArray[0]);
242        assertTrue("Failed to remove object", !ts.contains(objArray[0]));
243        assertTrue("Failed to change size after remove",
244                ts.size() == objArray.length - 1);
245        try {
246            ts.remove(new Object());
247        } catch (ClassCastException e) {
248            // Correct
249            return;
250        }
251        fail("Failed to throw exception when past uncomparable value");
252    }
253
254    /**
255     * java.util.TreeSet#size()
256     */
257    public void test_size() {
258        // Test for method int java.util.TreeSet.size()
259        assertTrue("Returned incorrect size", ts.size() == objArray.length);
260    }
261
262    /**
263     * java.util.TreeSet#subSet(java.lang.Object, java.lang.Object)
264     */
265    public void test_subSetLjava_lang_ObjectLjava_lang_Object() {
266        // Test for method java.util.SortedSet
267        // java.util.TreeSet.subSet(java.lang.Object, java.lang.Object)
268        final int startPos = objArray.length / 4;
269        final int endPos = 3 * objArray.length / 4;
270        SortedSet aSubSet = ts.subSet(objArray[startPos], objArray[endPos]);
271        assertTrue("Subset has wrong number of elements",
272                aSubSet.size() == (endPos - startPos));
273        for (int counter = startPos; counter < endPos; counter++)
274            assertTrue("Subset does not contain all the elements it should",
275                    aSubSet.contains(objArray[counter]));
276
277        int result;
278        try {
279            ts.subSet(objArray[3], objArray[0]);
280            result = 0;
281        } catch (IllegalArgumentException e) {
282            result = 1;
283        }
284        assertEquals("end less than start should throw", 1, result);
285    }
286
287    /**
288     * java.util.TreeSet#tailSet(java.lang.Object)
289     */
290    public void test_tailSetLjava_lang_Object() {
291        // Test for method java.util.SortedSet
292        // java.util.TreeSet.tailSet(java.lang.Object)
293        Set s = ts.tailSet(new Integer(900));
294        assertEquals("Returned set of incorrect size", 100, s.size());
295        for (int i = 900; i < objArray.length; i++)
296            assertTrue("Returned incorrect set", s.contains(objArray[i]));
297    }
298
299    /**
300     * Tests equals() method.
301     * Tests that no ClassCastException will be thrown in all cases.
302     * Regression test for HARMONY-1639.
303     */
304    public void test_equals() throws Exception {
305        // comparing TreeSets with different object types
306        Set s1 = new TreeSet();
307        Set s2 = new TreeSet();
308        s1.add("key1");
309        s1.add("key2");
310        s2.add(new Integer(1));
311        s2.add(new Integer(2));
312        assertFalse("Sets should not be equal 1", s1.equals(s2));
313        assertFalse("Sets should not be equal 2", s2.equals(s1));
314
315        // comparing TreeSet with HashSet
316        s1 = new TreeSet();
317        s2 = new HashSet();
318        s1.add("key");
319        s2.add(new Object());
320        assertFalse("Sets should not be equal 3", s1.equals(s2));
321        assertFalse("Sets should not be equal 4", s2.equals(s1));
322    }
323
324    /**
325     * Sets up the fixture, for example, open a network connection. This method
326     * is called before a test is executed.
327     */
328    protected void setUp() {
329        ts = new TreeSet();
330        for (int i = 0; i < objArray.length; i++) {
331            Object x = objArray[i] = new Integer(i);
332            ts.add(x);
333        }
334    }
335
336    /**
337     * Tears down the fixture, for example, close a network connection. This
338     * method is called after a test is executed.
339     */
340    protected void tearDown() {
341    }
342}
343