Parent Directory
| 
Revision Log
Revision 1.27 - (view) (download)
| 1 : | dl | 1.1 | /* |
| 2 : | dl | 1.7 | * Written by Doug Lea with assistance from members of JCP JSR-166 |
| 3 : | * Expert Group and released to the public domain, as explained at | ||
| 4 : | jsr166 | 1.26 | * http://creativecommons.org/publicdomain/zero/1.0/ |
| 5 : | jsr166 | 1.10 | * Other contributors include Andrew Wright, Jeffrey Hayes, |
| 6 : | * Pat Fisher, Mike Judd. | ||
| 7 : | dl | 1.1 | */ |
| 8 : | |||
| 9 : | import junit.framework.*; | ||
| 10 : | import java.util.*; | ||
| 11 : | import java.util.concurrent.*; | ||
| 12 : | |||
| 13 : | dl | 1.3 | public class LinkedListTest extends JSR166TestCase { |
| 14 : | dl | 1.1 | public static void main(String[] args) { |
| 15 : | jsr166 | 1.19 | junit.textui.TestRunner.run(suite()); |
| 16 : | dl | 1.1 | } |
| 17 : | |||
| 18 : | public static Test suite() { | ||
| 19 : | jsr166 | 1.13 | return new TestSuite(LinkedListTest.class); |
| 20 : | dl | 1.1 | } |
| 21 : | |||
| 22 : | /** | ||
| 23 : | * Create a queue of given size containing consecutive | ||
| 24 : | * Integers 0 ... n. | ||
| 25 : | */ | ||
| 26 : | jsr166 | 1.24 | private LinkedList<Integer> populatedQueue(int n) { |
| 27 : | LinkedList<Integer> q = new LinkedList<Integer>(); | ||
| 28 : | dl | 1.1 | assertTrue(q.isEmpty()); |
| 29 : | jsr166 | 1.13 | for (int i = 0; i < n; ++i) |
| 30 : | assertTrue(q.offer(new Integer(i))); | ||
| 31 : | dl | 1.1 | assertFalse(q.isEmpty()); |
| 32 : | jsr166 | 1.13 | assertEquals(n, q.size()); |
| 33 : | dl | 1.1 | return q; |
| 34 : | } | ||
| 35 : | jsr166 | 1.10 | |
| 36 : | dl | 1.4 | /** |
| 37 : | dl | 1.5 | * new queue is empty |
| 38 : | dl | 1.4 | */ |
| 39 : | public void testConstructor1() { | ||
| 40 : | dl | 1.1 | assertEquals(0, new LinkedList().size()); |
| 41 : | } | ||
| 42 : | |||
| 43 : | dl | 1.4 | /** |
| 44 : | dl | 1.5 | * Initializing from null Collection throws NPE |
| 45 : | dl | 1.4 | */ |
| 46 : | dl | 1.1 | public void testConstructor3() { |
| 47 : | try { | ||
| 48 : | LinkedList q = new LinkedList((Collection)null); | ||
| 49 : | dl | 1.4 | shouldThrow(); |
| 50 : | jsr166 | 1.14 | } catch (NullPointerException success) {} |
| 51 : | dl | 1.1 | } |
| 52 : | |||
| 53 : | dl | 1.4 | /** |
| 54 : | dl | 1.5 | * Queue contains all elements of collection used to initialize |
| 55 : | dl | 1.4 | */ |
| 56 : | public void testConstructor6() { | ||
| 57 : | jsr166 | 1.14 | Integer[] ints = new Integer[SIZE]; |
| 58 : | for (int i = 0; i < SIZE; ++i) | ||
| 59 : | jsr166 | 1.16 | ints[i] = i; |
| 60 : | jsr166 | 1.14 | LinkedList q = new LinkedList(Arrays.asList(ints)); |
| 61 : | for (int i = 0; i < SIZE; ++i) | ||
| 62 : | assertEquals(ints[i], q.poll()); | ||
| 63 : | dl | 1.1 | } |
| 64 : | |||
| 65 : | dl | 1.4 | /** |
| 66 : | dl | 1.5 | * isEmpty is true before add, false after |
| 67 : | dl | 1.4 | */ |
| 68 : | dl | 1.1 | public void testEmpty() { |
| 69 : | LinkedList q = new LinkedList(); | ||
| 70 : | assertTrue(q.isEmpty()); | ||
| 71 : | q.add(new Integer(1)); | ||
| 72 : | assertFalse(q.isEmpty()); | ||
| 73 : | q.add(new Integer(2)); | ||
| 74 : | q.remove(); | ||
| 75 : | q.remove(); | ||
| 76 : | assertTrue(q.isEmpty()); | ||
| 77 : | } | ||
| 78 : | |||
| 79 : | dl | 1.4 | /** |
| 80 : | dl | 1.5 | * size changes when elements added and removed |
| 81 : | dl | 1.4 | */ |
| 82 : | dl | 1.1 | public void testSize() { |
| 83 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 84 : | for (int i = 0; i < SIZE; ++i) { | ||
| 85 : | assertEquals(SIZE-i, q.size()); | ||
| 86 : | dl | 1.1 | q.remove(); |
| 87 : | } | ||
| 88 : | dl | 1.3 | for (int i = 0; i < SIZE; ++i) { |
| 89 : | dl | 1.1 | assertEquals(i, q.size()); |
| 90 : | q.add(new Integer(i)); | ||
| 91 : | } | ||
| 92 : | } | ||
| 93 : | |||
| 94 : | dl | 1.4 | /** |
| 95 : | dl | 1.5 | * offer(null) succeeds |
| 96 : | dl | 1.4 | */ |
| 97 : | public void testOfferNull() { | ||
| 98 : | jsr166 | 1.14 | LinkedList q = new LinkedList(); |
| 99 : | q.offer(null); | ||
| 100 : | dl | 1.1 | } |
| 101 : | |||
| 102 : | dl | 1.4 | /** |
| 103 : | jsr166 | 1.10 | * Offer succeeds |
| 104 : | dl | 1.4 | */ |
| 105 : | dl | 1.1 | public void testOffer() { |
| 106 : | LinkedList q = new LinkedList(); | ||
| 107 : | assertTrue(q.offer(new Integer(0))); | ||
| 108 : | assertTrue(q.offer(new Integer(1))); | ||
| 109 : | } | ||
| 110 : | |||
| 111 : | dl | 1.4 | /** |
| 112 : | dl | 1.5 | * add succeeds |
| 113 : | dl | 1.4 | */ |
| 114 : | public void testAdd() { | ||
| 115 : | dl | 1.1 | LinkedList q = new LinkedList(); |
| 116 : | dl | 1.3 | for (int i = 0; i < SIZE; ++i) { |
| 117 : | dl | 1.1 | assertEquals(i, q.size()); |
| 118 : | assertTrue(q.add(new Integer(i))); | ||
| 119 : | } | ||
| 120 : | } | ||
| 121 : | |||
| 122 : | dl | 1.4 | /** |
| 123 : | dl | 1.5 | * addAll(null) throws NPE |
| 124 : | dl | 1.4 | */ |
| 125 : | public void testAddAll1() { | ||
| 126 : | dl | 1.1 | try { |
| 127 : | LinkedList q = new LinkedList(); | ||
| 128 : | q.addAll(null); | ||
| 129 : | dl | 1.4 | shouldThrow(); |
| 130 : | jsr166 | 1.14 | } catch (NullPointerException success) {} |
| 131 : | dl | 1.1 | } |
| 132 : | |||
| 133 : | dl | 1.4 | /** |
| 134 : | dl | 1.5 | * Queue contains all elements, in traversal order, of successful addAll |
| 135 : | dl | 1.4 | */ |
| 136 : | public void testAddAll5() { | ||
| 137 : | jsr166 | 1.14 | Integer[] empty = new Integer[0]; |
| 138 : | Integer[] ints = new Integer[SIZE]; | ||
| 139 : | for (int i = 0; i < SIZE; ++i) | ||
| 140 : | jsr166 | 1.16 | ints[i] = i; |
| 141 : | jsr166 | 1.14 | LinkedList q = new LinkedList(); |
| 142 : | assertFalse(q.addAll(Arrays.asList(empty))); | ||
| 143 : | assertTrue(q.addAll(Arrays.asList(ints))); | ||
| 144 : | for (int i = 0; i < SIZE; ++i) | ||
| 145 : | assertEquals(ints[i], q.poll()); | ||
| 146 : | dl | 1.1 | } |
| 147 : | |||
| 148 : | dl | 1.4 | /** |
| 149 : | dl | 1.5 | * addAll with too large an index throws IOOBE |
| 150 : | */ | ||
| 151 : | public void testAddAll2_IndexOutOfBoundsException() { | ||
| 152 : | jsr166 | 1.14 | LinkedList l = new LinkedList(); |
| 153 : | l.add(new Object()); | ||
| 154 : | LinkedList m = new LinkedList(); | ||
| 155 : | m.add(new Object()); | ||
| 156 : | jsr166 | 1.13 | try { |
| 157 : | l.addAll(4,m); | ||
| 158 : | shouldThrow(); | ||
| 159 : | jsr166 | 1.15 | } catch (IndexOutOfBoundsException success) {} |
| 160 : | dl | 1.5 | } |
| 161 : | |||
| 162 : | /** | ||
| 163 : | * addAll with negative index throws IOOBE | ||
| 164 : | */ | ||
| 165 : | public void testAddAll4_BadIndex() { | ||
| 166 : | jsr166 | 1.14 | LinkedList l = new LinkedList(); |
| 167 : | l.add(new Object()); | ||
| 168 : | LinkedList m = new LinkedList(); | ||
| 169 : | m.add(new Object()); | ||
| 170 : | jsr166 | 1.13 | try { |
| 171 : | l.addAll(-1,m); | ||
| 172 : | shouldThrow(); | ||
| 173 : | jsr166 | 1.15 | } catch (IndexOutOfBoundsException success) {} |
| 174 : | dl | 1.5 | } |
| 175 : | |||
| 176 : | /** | ||
| 177 : | jsr166 | 1.20 | * poll succeeds unless empty |
| 178 : | dl | 1.4 | */ |
| 179 : | public void testPoll() { | ||
| 180 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 181 : | for (int i = 0; i < SIZE; ++i) { | ||
| 182 : | jsr166 | 1.16 | assertEquals(i, q.poll()); |
| 183 : | dl | 1.1 | } |
| 184 : | jsr166 | 1.13 | assertNull(q.poll()); |
| 185 : | dl | 1.1 | } |
| 186 : | |||
| 187 : | dl | 1.4 | /** |
| 188 : | jsr166 | 1.20 | * peek returns next element, or null if empty |
| 189 : | dl | 1.4 | */ |
| 190 : | public void testPeek() { | ||
| 191 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 192 : | for (int i = 0; i < SIZE; ++i) { | ||
| 193 : | jsr166 | 1.16 | assertEquals(i, q.peek()); |
| 194 : | assertEquals(i, q.poll()); | ||
| 195 : | dl | 1.1 | assertTrue(q.peek() == null || |
| 196 : | jsr166 | 1.16 | !q.peek().equals(i)); |
| 197 : | dl | 1.1 | } |
| 198 : | jsr166 | 1.13 | assertNull(q.peek()); |
| 199 : | dl | 1.1 | } |
| 200 : | |||
| 201 : | dl | 1.4 | /** |
| 202 : | dl | 1.6 | * element returns next element, or throws NSEE if empty |
| 203 : | dl | 1.4 | */ |
| 204 : | public void testElement() { | ||
| 205 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 206 : | for (int i = 0; i < SIZE; ++i) { | ||
| 207 : | jsr166 | 1.16 | assertEquals(i, q.element()); |
| 208 : | assertEquals(i, q.poll()); | ||
| 209 : | dl | 1.1 | } |
| 210 : | try { | ||
| 211 : | q.element(); | ||
| 212 : | dl | 1.4 | shouldThrow(); |
| 213 : | jsr166 | 1.14 | } catch (NoSuchElementException success) {} |
| 214 : | dl | 1.1 | } |
| 215 : | |||
| 216 : | dl | 1.4 | /** |
| 217 : | jsr166 | 1.20 | * remove removes next element, or throws NSEE if empty |
| 218 : | dl | 1.4 | */ |
| 219 : | public void testRemove() { | ||
| 220 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 221 : | for (int i = 0; i < SIZE; ++i) { | ||
| 222 : | jsr166 | 1.16 | assertEquals(i, q.remove()); |
| 223 : | dl | 1.1 | } |
| 224 : | try { | ||
| 225 : | q.remove(); | ||
| 226 : | dl | 1.4 | shouldThrow(); |
| 227 : | jsr166 | 1.14 | } catch (NoSuchElementException success) {} |
| 228 : | dl | 1.1 | } |
| 229 : | |||
| 230 : | dl | 1.4 | /** |
| 231 : | dl | 1.5 | * remove(x) removes x and returns true if present |
| 232 : | dl | 1.4 | */ |
| 233 : | public void testRemoveElement() { | ||
| 234 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 235 : | for (int i = 1; i < SIZE; i+=2) { | ||
| 236 : | jsr166 | 1.25 | assertTrue(q.contains(i)); |
| 237 : | assertTrue(q.remove((Integer)i)); | ||
| 238 : | assertFalse(q.contains(i)); | ||
| 239 : | assertTrue(q.contains(i-1)); | ||
| 240 : | dl | 1.1 | } |
| 241 : | dl | 1.3 | for (int i = 0; i < SIZE; i+=2) { |
| 242 : | jsr166 | 1.25 | assertTrue(q.contains(i)); |
| 243 : | assertTrue(q.remove((Integer)i)); | ||
| 244 : | assertFalse(q.contains(i)); | ||
| 245 : | assertFalse(q.remove((Integer)(i+1))); | ||
| 246 : | assertFalse(q.contains(i+1)); | ||
| 247 : | dl | 1.1 | } |
| 248 : | dl | 1.2 | assertTrue(q.isEmpty()); |
| 249 : | dl | 1.1 | } |
| 250 : | jsr166 | 1.10 | |
| 251 : | dl | 1.4 | /** |
| 252 : | dl | 1.5 | * contains(x) reports true when elements added but not yet removed |
| 253 : | dl | 1.4 | */ |
| 254 : | public void testContains() { | ||
| 255 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 256 : | for (int i = 0; i < SIZE; ++i) { | ||
| 257 : | dl | 1.1 | assertTrue(q.contains(new Integer(i))); |
| 258 : | q.poll(); | ||
| 259 : | assertFalse(q.contains(new Integer(i))); | ||
| 260 : | } | ||
| 261 : | } | ||
| 262 : | |||
| 263 : | dl | 1.4 | /** |
| 264 : | dl | 1.5 | * clear removes all elements |
| 265 : | dl | 1.4 | */ |
| 266 : | public void testClear() { | ||
| 267 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 268 : | dl | 1.1 | q.clear(); |
| 269 : | assertTrue(q.isEmpty()); | ||
| 270 : | assertEquals(0, q.size()); | ||
| 271 : | jsr166 | 1.16 | assertTrue(q.add(new Integer(1))); |
| 272 : | dl | 1.1 | assertFalse(q.isEmpty()); |
| 273 : | q.clear(); | ||
| 274 : | assertTrue(q.isEmpty()); | ||
| 275 : | } | ||
| 276 : | |||
| 277 : | dl | 1.4 | /** |
| 278 : | dl | 1.5 | * containsAll(c) is true when c contains a subset of elements |
| 279 : | dl | 1.4 | */ |
| 280 : | public void testContainsAll() { | ||
| 281 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 282 : | dl | 1.1 | LinkedList p = new LinkedList(); |
| 283 : | dl | 1.3 | for (int i = 0; i < SIZE; ++i) { |
| 284 : | dl | 1.1 | assertTrue(q.containsAll(p)); |
| 285 : | assertFalse(p.containsAll(q)); | ||
| 286 : | jsr166 | 1.16 | assertTrue(p.add(new Integer(i))); |
| 287 : | dl | 1.1 | } |
| 288 : | assertTrue(p.containsAll(q)); | ||
| 289 : | } | ||
| 290 : | |||
| 291 : | dl | 1.4 | /** |
| 292 : | dl | 1.5 | * retainAll(c) retains only those elements of c and reports true if changed |
| 293 : | dl | 1.4 | */ |
| 294 : | public void testRetainAll() { | ||
| 295 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 296 : | LinkedList p = populatedQueue(SIZE); | ||
| 297 : | for (int i = 0; i < SIZE; ++i) { | ||
| 298 : | dl | 1.1 | boolean changed = q.retainAll(p); |
| 299 : | if (i == 0) | ||
| 300 : | assertFalse(changed); | ||
| 301 : | else | ||
| 302 : | assertTrue(changed); | ||
| 303 : | |||
| 304 : | assertTrue(q.containsAll(p)); | ||
| 305 : | dl | 1.3 | assertEquals(SIZE-i, q.size()); |
| 306 : | dl | 1.1 | p.remove(); |
| 307 : | } | ||
| 308 : | } | ||
| 309 : | |||
| 310 : | dl | 1.4 | /** |
| 311 : | dl | 1.6 | * removeAll(c) removes only those elements of c and reports true if changed |
| 312 : | dl | 1.4 | */ |
| 313 : | public void testRemoveAll() { | ||
| 314 : | dl | 1.3 | for (int i = 1; i < SIZE; ++i) { |
| 315 : | LinkedList q = populatedQueue(SIZE); | ||
| 316 : | LinkedList p = populatedQueue(i); | ||
| 317 : | dl | 1.1 | assertTrue(q.removeAll(p)); |
| 318 : | dl | 1.3 | assertEquals(SIZE-i, q.size()); |
| 319 : | dl | 1.1 | for (int j = 0; j < i; ++j) { |
| 320 : | Integer I = (Integer)(p.remove()); | ||
| 321 : | assertFalse(q.contains(I)); | ||
| 322 : | } | ||
| 323 : | } | ||
| 324 : | } | ||
| 325 : | |||
| 326 : | dl | 1.4 | /** |
| 327 : | jsr166 | 1.23 | * toArray contains all elements in FIFO order |
| 328 : | dl | 1.4 | */ |
| 329 : | public void testToArray() { | ||
| 330 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 331 : | jsr166 | 1.13 | Object[] o = q.toArray(); |
| 332 : | for (int i = 0; i < o.length; i++) | ||
| 333 : | jsr166 | 1.23 | assertSame(o[i], q.poll()); |
| 334 : | dl | 1.1 | } |
| 335 : | |||
| 336 : | dl | 1.4 | /** |
| 337 : | jsr166 | 1.23 | * toArray(a) contains all elements in FIFO order |
| 338 : | dl | 1.4 | */ |
| 339 : | public void testToArray2() { | ||
| 340 : | jsr166 | 1.24 | LinkedList<Integer> q = populatedQueue(SIZE); |
| 341 : | jsr166 | 1.13 | Integer[] ints = new Integer[SIZE]; |
| 342 : | jsr166 | 1.24 | Integer[] array = q.toArray(ints); |
| 343 : | assertSame(ints, array); | ||
| 344 : | jsr166 | 1.11 | for (int i = 0; i < ints.length; i++) |
| 345 : | jsr166 | 1.23 | assertSame(ints[i], q.poll()); |
| 346 : | dl | 1.1 | } |
| 347 : | dl | 1.5 | |
| 348 : | /** | ||
| 349 : | jsr166 | 1.22 | * toArray(null) throws NullPointerException |
| 350 : | dl | 1.5 | */ |
| 351 : | jsr166 | 1.22 | public void testToArray_NullArg() { |
| 352 : | jsr166 | 1.16 | LinkedList l = new LinkedList(); |
| 353 : | l.add(new Object()); | ||
| 354 : | jsr166 | 1.13 | try { |
| 355 : | jsr166 | 1.22 | l.toArray(null); |
| 356 : | jsr166 | 1.13 | shouldThrow(); |
| 357 : | } catch (NullPointerException success) {} | ||
| 358 : | dl | 1.5 | } |
| 359 : | |||
| 360 : | /** | ||
| 361 : | jsr166 | 1.21 | * toArray(incompatible array type) throws ArrayStoreException |
| 362 : | dl | 1.5 | */ |
| 363 : | public void testToArray1_BadArg() { | ||
| 364 : | jsr166 | 1.16 | LinkedList l = new LinkedList(); |
| 365 : | l.add(new Integer(5)); | ||
| 366 : | jsr166 | 1.13 | try { |
| 367 : | jsr166 | 1.21 | l.toArray(new String[10]); |
| 368 : | jsr166 | 1.13 | shouldThrow(); |
| 369 : | jsr166 | 1.14 | } catch (ArrayStoreException success) {} |
| 370 : | dl | 1.5 | } |
| 371 : | jsr166 | 1.10 | |
| 372 : | dl | 1.4 | /** |
| 373 : | jsr166 | 1.20 | * iterator iterates through all elements |
| 374 : | dl | 1.4 | */ |
| 375 : | public void testIterator() { | ||
| 376 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 377 : | dl | 1.1 | int i = 0; |
| 378 : | jsr166 | 1.13 | Iterator it = q.iterator(); |
| 379 : | jsr166 | 1.11 | while (it.hasNext()) { |
| 380 : | dl | 1.1 | assertTrue(q.contains(it.next())); |
| 381 : | ++i; | ||
| 382 : | } | ||
| 383 : | dl | 1.3 | assertEquals(i, SIZE); |
| 384 : | dl | 1.1 | } |
| 385 : | |||
| 386 : | dl | 1.4 | /** |
| 387 : | jsr166 | 1.20 | * iterator ordering is FIFO |
| 388 : | dl | 1.4 | */ |
| 389 : | dl | 1.1 | public void testIteratorOrdering() { |
| 390 : | final LinkedList q = new LinkedList(); | ||
| 391 : | q.add(new Integer(1)); | ||
| 392 : | q.add(new Integer(2)); | ||
| 393 : | q.add(new Integer(3)); | ||
| 394 : | int k = 0; | ||
| 395 : | for (Iterator it = q.iterator(); it.hasNext();) { | ||
| 396 : | jsr166 | 1.16 | assertEquals(++k, it.next()); |
| 397 : | dl | 1.1 | } |
| 398 : | |||
| 399 : | dl | 1.4 | assertEquals(3, k); |
| 400 : | dl | 1.1 | } |
| 401 : | |||
| 402 : | dl | 1.4 | /** |
| 403 : | dl | 1.5 | * iterator.remove removes current element |
| 404 : | dl | 1.4 | */ |
| 405 : | jsr166 | 1.19 | public void testIteratorRemove() { |
| 406 : | dl | 1.1 | final LinkedList q = new LinkedList(); |
| 407 : | q.add(new Integer(1)); | ||
| 408 : | q.add(new Integer(2)); | ||
| 409 : | q.add(new Integer(3)); | ||
| 410 : | Iterator it = q.iterator(); | ||
| 411 : | jsr166 | 1.16 | assertEquals(it.next(), 1); |
| 412 : | dl | 1.1 | it.remove(); |
| 413 : | it = q.iterator(); | ||
| 414 : | jsr166 | 1.16 | assertEquals(it.next(), 2); |
| 415 : | assertEquals(it.next(), 3); | ||
| 416 : | dl | 1.1 | assertFalse(it.hasNext()); |
| 417 : | } | ||
| 418 : | |||
| 419 : | dl | 1.9 | /** |
| 420 : | jsr166 | 1.20 | * Descending iterator iterates through all elements |
| 421 : | dl | 1.9 | */ |
| 422 : | public void testDescendingIterator() { | ||
| 423 : | LinkedList q = populatedQueue(SIZE); | ||
| 424 : | int i = 0; | ||
| 425 : | jsr166 | 1.13 | Iterator it = q.descendingIterator(); |
| 426 : | jsr166 | 1.11 | while (it.hasNext()) { |
| 427 : | dl | 1.9 | assertTrue(q.contains(it.next())); |
| 428 : | ++i; | ||
| 429 : | } | ||
| 430 : | assertEquals(i, SIZE); | ||
| 431 : | assertFalse(it.hasNext()); | ||
| 432 : | try { | ||
| 433 : | it.next(); | ||
| 434 : | jsr166 | 1.14 | shouldThrow(); |
| 435 : | } catch (NoSuchElementException success) {} | ||
| 436 : | dl | 1.9 | } |
| 437 : | |||
| 438 : | /** | ||
| 439 : | jsr166 | 1.20 | * Descending iterator ordering is reverse FIFO |
| 440 : | dl | 1.9 | */ |
| 441 : | public void testDescendingIteratorOrdering() { | ||
| 442 : | final LinkedList q = new LinkedList(); | ||
| 443 : | q.add(new Integer(3)); | ||
| 444 : | q.add(new Integer(2)); | ||
| 445 : | q.add(new Integer(1)); | ||
| 446 : | int k = 0; | ||
| 447 : | for (Iterator it = q.descendingIterator(); it.hasNext();) { | ||
| 448 : | jsr166 | 1.16 | assertEquals(++k, it.next()); |
| 449 : | dl | 1.9 | } |
| 450 : | |||
| 451 : | assertEquals(3, k); | ||
| 452 : | } | ||
| 453 : | |||
| 454 : | /** | ||
| 455 : | * descendingIterator.remove removes current element | ||
| 456 : | */ | ||
| 457 : | jsr166 | 1.19 | public void testDescendingIteratorRemove() { |
| 458 : | dl | 1.9 | final LinkedList q = new LinkedList(); |
| 459 : | jsr166 | 1.17 | q.add(three); |
| 460 : | q.add(two); | ||
| 461 : | q.add(one); | ||
| 462 : | dl | 1.9 | Iterator it = q.descendingIterator(); |
| 463 : | it.next(); | ||
| 464 : | it.remove(); | ||
| 465 : | it = q.descendingIterator(); | ||
| 466 : | jsr166 | 1.17 | assertSame(it.next(), two); |
| 467 : | assertSame(it.next(), three); | ||
| 468 : | dl | 1.9 | assertFalse(it.hasNext()); |
| 469 : | } | ||
| 470 : | |||
| 471 : | dl | 1.4 | /** |
| 472 : | dl | 1.5 | * toString contains toStrings of elements |
| 473 : | dl | 1.4 | */ |
| 474 : | public void testToString() { | ||
| 475 : | dl | 1.3 | LinkedList q = populatedQueue(SIZE); |
| 476 : | dl | 1.1 | String s = q.toString(); |
| 477 : | dl | 1.3 | for (int i = 0; i < SIZE; ++i) { |
| 478 : | jsr166 | 1.27 | assertTrue(s.contains(String.valueOf(i))); |
| 479 : | dl | 1.1 | } |
| 480 : | jsr166 | 1.10 | } |
| 481 : | dl | 1.1 | |
| 482 : | dl | 1.4 | /** |
| 483 : | dl | 1.5 | * peek returns element inserted with addFirst |
| 484 : | dl | 1.4 | */ |
| 485 : | public void testAddFirst() { | ||
| 486 : | dl | 1.3 | LinkedList q = populatedQueue(3); |
| 487 : | jsr166 | 1.13 | q.addFirst(four); |
| 488 : | jsr166 | 1.17 | assertSame(four, q.peek()); |
| 489 : | jsr166 | 1.10 | } |
| 490 : | dl | 1.1 | |
| 491 : | dl | 1.8 | /** |
| 492 : | * peekFirst returns element inserted with push | ||
| 493 : | */ | ||
| 494 : | public void testPush() { | ||
| 495 : | LinkedList q = populatedQueue(3); | ||
| 496 : | jsr166 | 1.13 | q.push(four); |
| 497 : | jsr166 | 1.17 | assertSame(four, q.peekFirst()); |
| 498 : | jsr166 | 1.10 | } |
| 499 : | dl | 1.8 | |
| 500 : | /** | ||
| 501 : | jsr166 | 1.20 | * pop removes next element, or throws NSEE if empty |
| 502 : | dl | 1.8 | */ |
| 503 : | public void testPop() { | ||
| 504 : | LinkedList q = populatedQueue(SIZE); | ||
| 505 : | for (int i = 0; i < SIZE; ++i) { | ||
| 506 : | jsr166 | 1.16 | assertEquals(i, q.pop()); |
| 507 : | dl | 1.8 | } |
| 508 : | try { | ||
| 509 : | q.pop(); | ||
| 510 : | shouldThrow(); | ||
| 511 : | jsr166 | 1.14 | } catch (NoSuchElementException success) {} |
| 512 : | dl | 1.8 | } |
| 513 : | |||
| 514 : | /** | ||
| 515 : | jsr166 | 1.10 | * OfferFirst succeeds |
| 516 : | dl | 1.8 | */ |
| 517 : | public void testOfferFirst() { | ||
| 518 : | LinkedList q = new LinkedList(); | ||
| 519 : | assertTrue(q.offerFirst(new Integer(0))); | ||
| 520 : | assertTrue(q.offerFirst(new Integer(1))); | ||
| 521 : | } | ||
| 522 : | |||
| 523 : | /** | ||
| 524 : | jsr166 | 1.10 | * OfferLast succeeds |
| 525 : | dl | 1.8 | */ |
| 526 : | public void testOfferLast() { | ||
| 527 : | LinkedList q = new LinkedList(); | ||
| 528 : | assertTrue(q.offerLast(new Integer(0))); | ||
| 529 : | assertTrue(q.offerLast(new Integer(1))); | ||
| 530 : | } | ||
| 531 : | |||
| 532 : | /** | ||
| 533 : | jsr166 | 1.20 | * pollLast succeeds unless empty |
| 534 : | dl | 1.8 | */ |
| 535 : | public void testPollLast() { | ||
| 536 : | LinkedList q = populatedQueue(SIZE); | ||
| 537 : | for (int i = SIZE-1; i >= 0; --i) { | ||
| 538 : | jsr166 | 1.16 | assertEquals(i, q.pollLast()); |
| 539 : | dl | 1.8 | } |
| 540 : | jsr166 | 1.13 | assertNull(q.pollLast()); |
| 541 : | dl | 1.8 | } |
| 542 : | |||
| 543 : | /** | ||
| 544 : | jsr166 | 1.20 | * peekFirst returns next element, or null if empty |
| 545 : | dl | 1.8 | */ |
| 546 : | public void testPeekFirst() { | ||
| 547 : | LinkedList q = populatedQueue(SIZE); | ||
| 548 : | for (int i = 0; i < SIZE; ++i) { | ||
| 549 : | jsr166 | 1.16 | assertEquals(i, q.peekFirst()); |
| 550 : | assertEquals(i, q.pollFirst()); | ||
| 551 : | dl | 1.8 | assertTrue(q.peekFirst() == null || |
| 552 : | jsr166 | 1.16 | !q.peekFirst().equals(i)); |
| 553 : | dl | 1.8 | } |
| 554 : | jsr166 | 1.13 | assertNull(q.peekFirst()); |
| 555 : | dl | 1.8 | } |
| 556 : | |||
| 557 : | /** | ||
| 558 : | jsr166 | 1.20 | * peekLast returns next element, or null if empty |
| 559 : | dl | 1.8 | */ |
| 560 : | public void testPeekLast() { | ||
| 561 : | LinkedList q = populatedQueue(SIZE); | ||
| 562 : | for (int i = SIZE-1; i >= 0; --i) { | ||
| 563 : | jsr166 | 1.16 | assertEquals(i, q.peekLast()); |
| 564 : | assertEquals(i, q.pollLast()); | ||
| 565 : | dl | 1.8 | assertTrue(q.peekLast() == null || |
| 566 : | jsr166 | 1.16 | !q.peekLast().equals(i)); |
| 567 : | dl | 1.8 | } |
| 568 : | jsr166 | 1.13 | assertNull(q.peekLast()); |
| 569 : | dl | 1.8 | } |
| 570 : | |||
| 571 : | public void testFirstElement() { | ||
| 572 : | LinkedList q = populatedQueue(SIZE); | ||
| 573 : | for (int i = 0; i < SIZE; ++i) { | ||
| 574 : | jsr166 | 1.16 | assertEquals(i, q.getFirst()); |
| 575 : | assertEquals(i, q.pollFirst()); | ||
| 576 : | dl | 1.8 | } |
| 577 : | try { | ||
| 578 : | q.getFirst(); | ||
| 579 : | shouldThrow(); | ||
| 580 : | jsr166 | 1.14 | } catch (NoSuchElementException success) {} |
| 581 : | dl | 1.8 | } |
| 582 : | |||
| 583 : | /** | ||
| 584 : | jsr166 | 1.20 | * getLast returns next element, or throws NSEE if empty |
| 585 : | dl | 1.8 | */ |
| 586 : | public void testLastElement() { | ||
| 587 : | LinkedList q = populatedQueue(SIZE); | ||
| 588 : | for (int i = SIZE-1; i >= 0; --i) { | ||
| 589 : | jsr166 | 1.16 | assertEquals(i, q.getLast()); |
| 590 : | assertEquals(i, q.pollLast()); | ||
| 591 : | dl | 1.8 | } |
| 592 : | try { | ||
| 593 : | q.getLast(); | ||
| 594 : | shouldThrow(); | ||
| 595 : | jsr166 | 1.14 | } catch (NoSuchElementException success) {} |
| 596 : | jsr166 | 1.13 | assertNull(q.peekLast()); |
| 597 : | dl | 1.8 | } |
| 598 : | |||
| 599 : | /** | ||
| 600 : | * removeFirstOccurrence(x) removes x and returns true if present | ||
| 601 : | */ | ||
| 602 : | public void testRemoveFirstOccurrence() { | ||
| 603 : | LinkedList q = populatedQueue(SIZE); | ||
| 604 : | for (int i = 1; i < SIZE; i+=2) { | ||
| 605 : | assertTrue(q.removeFirstOccurrence(new Integer(i))); | ||
| 606 : | } | ||
| 607 : | for (int i = 0; i < SIZE; i+=2) { | ||
| 608 : | assertTrue(q.removeFirstOccurrence(new Integer(i))); | ||
| 609 : | assertFalse(q.removeFirstOccurrence(new Integer(i+1))); | ||
| 610 : | } | ||
| 611 : | assertTrue(q.isEmpty()); | ||
| 612 : | } | ||
| 613 : | |||
| 614 : | /** | ||
| 615 : | * removeLastOccurrence(x) removes x and returns true if present | ||
| 616 : | */ | ||
| 617 : | public void testRemoveLastOccurrence() { | ||
| 618 : | LinkedList q = populatedQueue(SIZE); | ||
| 619 : | for (int i = 1; i < SIZE; i+=2) { | ||
| 620 : | assertTrue(q.removeLastOccurrence(new Integer(i))); | ||
| 621 : | } | ||
| 622 : | for (int i = 0; i < SIZE; i+=2) { | ||
| 623 : | assertTrue(q.removeLastOccurrence(new Integer(i))); | ||
| 624 : | assertFalse(q.removeLastOccurrence(new Integer(i+1))); | ||
| 625 : | } | ||
| 626 : | assertTrue(q.isEmpty()); | ||
| 627 : | } | ||
| 628 : | |||
| 629 : | dl | 1.1 | } |
| Doug Lea | ViewVC Help |
| Powered by ViewVC 1.0.8 |