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 18 package org.apache.harmony.tests.java.util; 19 20 import java.util.Arrays; 21 import java.util.Comparator; 22 import java.util.HashSet; 23 import java.util.Iterator; 24 import java.util.Set; 25 import java.util.SortedSet; 26 import java.util.TreeSet; 27 28 public 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
