1/* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to You under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package tests.api.java.util; 18 19import java.util.Arrays; 20import java.util.Collection; 21import java.util.Iterator; 22import java.util.LinkedHashSet; 23import java.util.Set; 24import java.util.Vector; 25 26/** 27 * java.util.LinkedHashSet 28 */ 29 30public class LinkedHashSetTest extends junit.framework.TestCase { 31 32 LinkedHashSet hs; 33 34 Object[] objArray; 35 36 /** 37 * java.util.LinkedHashSet#LinkedHashSet() 38 */ 39 public void test_Constructor() { 40 // Test for method java.util.LinkedHashSet() 41 LinkedHashSet hs2 = new LinkedHashSet(); 42 assertEquals("Created incorrect LinkedHashSet", 0, hs2.size()); 43 } 44 45 /** 46 * java.util.LinkedHashSet#LinkedHashSet(int) 47 */ 48 public void test_ConstructorI() { 49 // Test for method java.util.LinkedHashSet(int) 50 LinkedHashSet hs2 = new LinkedHashSet(5); 51 assertEquals("Created incorrect LinkedHashSet", 0, hs2.size()); 52 try { 53 new LinkedHashSet(-1); 54 fail("IllegalArgumentException expected"); 55 } catch (IllegalArgumentException e) { 56 //expected 57 } 58 } 59 60 /** 61 * java.util.LinkedHashSet#LinkedHashSet(int, float) 62 */ 63 public void test_ConstructorIF() { 64 // Test for method java.util.LinkedHashSet(int, float) 65 LinkedHashSet hs2 = new LinkedHashSet(5, (float) 0.5); 66 assertEquals("Created incorrect LinkedHashSet", 0, hs2.size()); 67 68 try { 69 new LinkedHashSet(-1, 0.5f); 70 fail("IllegalArgumentException expected"); 71 } catch (IllegalArgumentException e) { 72 //expected 73 } 74 75 try { 76 new LinkedHashSet(1, -0.5f); 77 fail("IllegalArgumentException expected"); 78 } catch (IllegalArgumentException e) { 79 //expected 80 } 81 82 try { 83 new LinkedHashSet(1, 0f); 84 fail("IllegalArgumentException expected"); 85 } catch (IllegalArgumentException e) { 86 //expected 87 } 88 } 89 90 /** 91 * java.util.LinkedHashSet#LinkedHashSet(java.util.Collection) 92 */ 93 public void test_ConstructorLjava_util_Collection() { 94 // Test for method java.util.LinkedHashSet(java.util.Collection) 95 LinkedHashSet hs2 = new LinkedHashSet(Arrays.asList(objArray)); 96 for (int counter = 0; counter < objArray.length; counter++) 97 assertTrue("LinkedHashSet does not contain correct elements", hs 98 .contains(objArray[counter])); 99 assertTrue("LinkedHashSet created from collection incorrect size", hs2 100 .size() == objArray.length); 101 102 try { 103 new LinkedHashSet(null); 104 fail("NullPointerException expected"); 105 } catch (NullPointerException e) { 106 //expected 107 } 108 } 109 110 /** 111 * java.util.LinkedHashSet#add(java.lang.Object) 112 */ 113 public void test_addLjava_lang_Object() { 114 // Test for method boolean java.util.LinkedHashSet.add(java.lang.Object) 115 int size = hs.size(); 116 hs.add(new Integer(8)); 117 assertTrue("Added element already contained by set", hs.size() == size); 118 hs.add(new Integer(-9)); 119 assertTrue("Failed to increment set size after add", 120 hs.size() == size + 1); 121 assertTrue("Failed to add element to set", hs.contains(new Integer(-9))); 122 } 123 124 /** 125 * java.util.LinkedHashSet#clear() 126 */ 127 public void test_clear() { 128 // Test for method void java.util.LinkedHashSet.clear() 129 Set orgSet = (Set) hs.clone(); 130 hs.clear(); 131 Iterator i = orgSet.iterator(); 132 assertEquals("Returned non-zero size after clear", 0, hs.size()); 133 while (i.hasNext()) 134 assertTrue("Failed to clear set", !hs.contains(i.next())); 135 } 136 137 /** 138 * java.util.LinkedHashSet#clone() 139 */ 140 public void test_clone() { 141 // Test for method java.lang.Object java.util.LinkedHashSet.clone() 142 LinkedHashSet hs2 = (LinkedHashSet) hs.clone(); 143 assertTrue("clone returned an equivalent LinkedHashSet", hs != hs2); 144 assertTrue("clone did not return an equal LinkedHashSet", hs 145 .equals(hs2)); 146 } 147 148 /** 149 * java.util.LinkedHashSet#contains(java.lang.Object) 150 */ 151 public void test_containsLjava_lang_Object() { 152 // Test for method boolean 153 // java.util.LinkedHashSet.contains(java.lang.Object) 154 assertTrue("Returned false for valid object", hs.contains(objArray[90])); 155 assertTrue("Returned true for invalid Object", !hs 156 .contains(new Object())); 157 158 LinkedHashSet s = new LinkedHashSet(); 159 s.add(null); 160 assertTrue("Cannot handle null", s.contains(null)); 161 } 162 163 /** 164 * java.util.LinkedHashSet#isEmpty() 165 */ 166 public void test_isEmpty() { 167 // Test for method boolean java.util.LinkedHashSet.isEmpty() 168 assertTrue("Empty set returned false", new LinkedHashSet().isEmpty()); 169 assertTrue("Non-empty set returned true", !hs.isEmpty()); 170 } 171 172 /** 173 * java.util.LinkedHashSet#iterator() 174 */ 175 public void test_iterator() { 176 // Test for method java.util.Iterator java.util.LinkedHashSet.iterator() 177 Iterator i = hs.iterator(); 178 int x = 0; 179 int j; 180 for (j = 0; i.hasNext(); j++) { 181 Object oo = i.next(); 182 if (oo != null) { 183 Integer ii = (Integer) oo; 184 assertTrue("Incorrect element found", ii.intValue() == j); 185 } else { 186 assertTrue("Cannot find null", hs.contains(oo)); 187 } 188 ++x; 189 } 190 assertTrue("Returned iteration of incorrect size", hs.size() == x); 191 192 LinkedHashSet s = new LinkedHashSet(); 193 s.add(null); 194 assertNull("Cannot handle null", s.iterator().next()); 195 } 196 197 /** 198 * java.util.LinkedHashSet#remove(java.lang.Object) 199 */ 200 public void test_removeLjava_lang_Object() { 201 // Test for method boolean 202 // java.util.LinkedHashSet.remove(java.lang.Object) 203 int size = hs.size(); 204 hs.remove(new Integer(98)); 205 assertTrue("Failed to remove element", !hs.contains(new Integer(98))); 206 assertTrue("Failed to decrement set size", hs.size() == size - 1); 207 208 LinkedHashSet s = new LinkedHashSet(); 209 s.add(null); 210 assertTrue("Cannot handle null", s.remove(null)); 211 } 212 213 /** 214 * java.util.LinkedHashSet#size() 215 */ 216 public void test_size() { 217 // Test for method int java.util.LinkedHashSet.size() 218 assertTrue("Returned incorrect size", hs.size() == (objArray.length + 1)); 219 hs.clear(); 220 assertEquals("Cleared set returned non-zero size", 0, hs.size()); 221 } 222 223 class Mock_LinkedHashSet extends LinkedHashSet { 224 @Override 225 public boolean retainAll(Collection c) { 226 throw new UnsupportedOperationException(); 227 } 228 } 229 230 public void test_retainAllLjava_util_Collection() { 231 LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>(); 232 Vector v = new Vector<Float>(); 233 v.add(new Float(3.14)); 234 lhs.add(new Integer(1)); 235 assertEquals(1, lhs.size()); 236 lhs.retainAll(v); 237 assertEquals(0, lhs.size()); 238 v = new Vector<Integer>(); 239 v.add(new Integer(1)); 240 v.add(new Integer(2)); 241 v.add(new Integer(3)); 242 v.add(new Integer(4)); 243 v.add(new Integer(5)); 244 v.add(new Integer(6)); 245 lhs.add(new Integer(1)); 246 lhs.add(new Integer(6)); 247 lhs.add(new Integer(7)); 248 lhs.add(new Integer(8)); 249 lhs.add(new Integer(9)); 250 lhs.add(new Integer(10)); 251 lhs.add(new Integer(11)); 252 lhs.add(new Integer(12)); 253 lhs.add(new Integer(13)); 254 assertEquals(9, lhs.size()); 255 lhs.retainAll(v); 256 assertEquals(2, lhs.size()); 257 258 try { 259 lhs.retainAll(null); 260 fail("NullPointerException expected"); 261 } catch (NullPointerException e) { 262 //expected 263 } 264 265 lhs = new Mock_LinkedHashSet(); 266 267 try { 268 lhs.retainAll(v); 269 fail("UnsupportedOperationException expected"); 270 } catch (UnsupportedOperationException e) { 271 //expected 272 } 273 } 274 275 public void test_toArray() { 276 LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>(); 277 lhs.add(new Integer(1)); 278 lhs.add(new Integer(6)); 279 lhs.add(new Integer(7)); 280 lhs.add(new Integer(8)); 281 lhs.add(new Integer(9)); 282 lhs.add(new Integer(10)); 283 lhs.add(new Integer(11)); 284 lhs.add(new Integer(12)); 285 lhs.add(new Integer(13)); 286 287 Object[] o = lhs.toArray(); 288 for (int i = 0; i < o.length; i++) { 289 assertTrue(lhs.contains(o[i])); 290 } 291 assertEquals(lhs.size(), o.length); 292 } 293 294 public void test_toArray$Ljava_lang_Object() { 295 LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>(); 296 lhs.add(new Integer(1)); 297 lhs.add(new Integer(6)); 298 lhs.add(new Integer(7)); 299 lhs.add(new Integer(8)); 300 lhs.add(new Integer(9)); 301 lhs.add(new Integer(10)); 302 lhs.add(new Integer(11)); 303 lhs.add(new Integer(12)); 304 lhs.add(new Integer(13)); 305 306 Object[] o1 = new Object[lhs.size()]; 307 Object[] o2 = new Double[lhs.size()]; 308 lhs.toArray(o1); 309 for (int i = 0; i < o1.length; i++) { 310 assertTrue(lhs.contains(o1[i])); 311 } 312 313 try { 314 lhs.toArray(null); 315 fail("NullPointerException expected"); 316 } catch (NullPointerException e) { 317 //expected 318 } 319 320 try { 321 lhs.toArray(o2); 322 fail("ArrayStoreException expected"); 323 } catch (ArrayStoreException e) { 324 //expected 325 } 326 } 327 328 /** 329 * Sets up the fixture, for example, open a network connection. This method 330 * is called before a test is executed. 331 */ 332 protected void setUp() { 333 objArray = new Object[1000]; 334 for (int i = 0; i < objArray.length; i++) 335 objArray[i] = new Integer(i); 336 337 hs = new LinkedHashSet(); 338 for (int i = 0; i < objArray.length; i++) 339 hs.add(objArray[i]); 340 hs.add(null); 341 } 342 343 /** 344 * Tears down the fixture, for example, close a network connection. This 345 * method is called after a test is executed. 346 */ 347 protected void tearDown() { 348 objArray = null; 349 hs = null; 350 } 351} 352