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.luni.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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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	 * @tests 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        // comparing TreeSets with not-comparable objects inside
324        s1 = new TreeSet();
325        s2 = new TreeSet();
326        s1.add(new Object());
327        s2.add(new Object());
328        assertFalse("Sets should not be equal 5", s1.equals(s2));
329        assertFalse("Sets should not be equal 6", s2.equals(s1));
330    }
331
332	/**
333	 * Sets up the fixture, for example, open a network connection. This method
334	 * is called before a test is executed.
335	 */
336	protected void setUp() {
337		ts = new TreeSet();
338		for (int i = 0; i < objArray.length; i++) {
339			Object x = objArray[i] = new Integer(i);
340			ts.add(x);
341		}
342	}
343
344	/**
345	 * Tears down the fixture, for example, close a network connection. This
346	 * method is called after a test is executed.
347	 */
348	protected void tearDown() {
349	}
350}
351