[cvs] / jsr166 / src / test / tck / LinkedListTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/LinkedListTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.5, Thu Sep 25 11:02:41 2003 UTC revision 1.9, Wed Sep 14 23:50:31 2005 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/licenses/publicdomain
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9  import junit.framework.*;  import junit.framework.*;
# Line 211  Line 212 
212      }      }
213    
214      /**      /**
215       *       * element returns next element, or throws NSEE if empty
216       */       */
217      public void testElement() {      public void testElement() {
218          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 227  Line 228 
228      }      }
229    
230      /**      /**
231       * element returns next element, or throws NSEE if empty       *  remove removes next element, or throws NSEE if empty
232       */       */
233      public void testRemove() {      public void testRemove() {
234          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 426  Line 427 
427          assertFalse(it.hasNext());          assertFalse(it.hasNext());
428      }      }
429    
430        /**
431         *  Descending iterator iterates through all elements
432         */
433        public void testDescendingIterator() {
434            LinkedList q = populatedQueue(SIZE);
435            int i = 0;
436            Iterator it = q.descendingIterator();
437            while(it.hasNext()) {
438                assertTrue(q.contains(it.next()));
439                ++i;
440            }
441            assertEquals(i, SIZE);
442            assertFalse(it.hasNext());
443            try {
444                it.next();
445            } catch(NoSuchElementException success) {
446            }
447        }
448    
449        /**
450         *  Descending iterator ordering is reverse FIFO
451         */
452        public void testDescendingIteratorOrdering() {
453            final LinkedList q = new LinkedList();
454            q.add(new Integer(3));
455            q.add(new Integer(2));
456            q.add(new Integer(1));
457            int k = 0;
458            for (Iterator it = q.descendingIterator(); it.hasNext();) {
459                int i = ((Integer)(it.next())).intValue();
460                assertEquals(++k, i);
461            }
462    
463            assertEquals(3, k);
464        }
465    
466        /**
467         * descendingIterator.remove removes current element
468         */
469        public void testDescendingIteratorRemove () {
470            final LinkedList q = new LinkedList();
471            q.add(new Integer(3));
472            q.add(new Integer(2));
473            q.add(new Integer(1));
474            Iterator it = q.descendingIterator();
475            it.next();
476            it.remove();
477            it = q.descendingIterator();
478            assertEquals(it.next(), new Integer(2));
479            assertEquals(it.next(), new Integer(3));
480            assertFalse(it.hasNext());
481        }
482    
483    
484      /**      /**
485       * toString contains toStrings of elements       * toString contains toStrings of elements
# Line 447  Line 501 
501          assertEquals(four,q.peek());          assertEquals(four,q.peek());
502      }      }
503    
504        /**
505         * peekFirst returns element inserted with push
506         */
507        public void testPush() {
508            LinkedList q = populatedQueue(3);
509            q.pollLast();
510            q.push(four);
511            assertEquals(four,q.peekFirst());
512        }
513    
514        /**
515         *  pop removes next element, or throws NSEE if empty
516         */
517        public void testPop() {
518            LinkedList q = populatedQueue(SIZE);
519            for (int i = 0; i < SIZE; ++i) {
520                assertEquals(i, ((Integer)q.pop()).intValue());
521            }
522            try {
523                q.pop();
524                shouldThrow();
525            } catch (NoSuchElementException success){
526            }
527        }
528    
529        /**
530         * OfferFirst succeeds
531         */
532        public void testOfferFirst() {
533            LinkedList q = new LinkedList();
534            assertTrue(q.offerFirst(new Integer(0)));
535            assertTrue(q.offerFirst(new Integer(1)));
536        }
537    
538        /**
539         * OfferLast succeeds
540         */
541        public void testOfferLast() {
542            LinkedList q = new LinkedList();
543            assertTrue(q.offerLast(new Integer(0)));
544            assertTrue(q.offerLast(new Integer(1)));
545        }
546    
547        /**
548         *  pollLast succeeds unless empty
549         */
550        public void testPollLast() {
551            LinkedList q = populatedQueue(SIZE);
552            for (int i = SIZE-1; i >= 0; --i) {
553                assertEquals(i, ((Integer)q.pollLast()).intValue());
554            }
555            assertNull(q.pollLast());
556        }
557    
558        /**
559         *  peekFirst returns next element, or null if empty
560         */
561        public void testPeekFirst() {
562            LinkedList q = populatedQueue(SIZE);
563            for (int i = 0; i < SIZE; ++i) {
564                assertEquals(i, ((Integer)q.peekFirst()).intValue());
565                q.pollFirst();
566                assertTrue(q.peekFirst() == null ||
567                           i != ((Integer)q.peekFirst()).intValue());
568            }
569            assertNull(q.peekFirst());
570        }
571    
572    
573        /**
574         *  peekLast returns next element, or null if empty
575         */
576        public void testPeekLast() {
577            LinkedList q = populatedQueue(SIZE);
578            for (int i = SIZE-1; i >= 0; --i) {
579                assertEquals(i, ((Integer)q.peekLast()).intValue());
580                q.pollLast();
581                assertTrue(q.peekLast() == null ||
582                           i != ((Integer)q.peekLast()).intValue());
583            }
584            assertNull(q.peekLast());
585        }
586    
587        public void testFirstElement() {
588            LinkedList q = populatedQueue(SIZE);
589            for (int i = 0; i < SIZE; ++i) {
590                assertEquals(i, ((Integer)q.getFirst()).intValue());
591                q.pollFirst();
592            }
593            try {
594                q.getFirst();
595                shouldThrow();
596            }
597            catch (NoSuchElementException success) {}
598        }
599    
600        /**
601         *  getLast returns next element, or throws NSEE if empty
602         */
603        public void testLastElement() {
604            LinkedList q = populatedQueue(SIZE);
605            for (int i = SIZE-1; i >= 0; --i) {
606                assertEquals(i, ((Integer)q.getLast()).intValue());
607                q.pollLast();
608            }
609            try {
610                q.getLast();
611                shouldThrow();
612            }
613            catch (NoSuchElementException success) {}
614            assertNull(q.peekLast());
615        }
616    
617        /**
618         * removeFirstOccurrence(x) removes x and returns true if present
619         */
620        public void testRemoveFirstOccurrence() {
621            LinkedList q = populatedQueue(SIZE);
622            for (int i = 1; i < SIZE; i+=2) {
623                assertTrue(q.removeFirstOccurrence(new Integer(i)));
624            }
625            for (int i = 0; i < SIZE; i+=2) {
626                assertTrue(q.removeFirstOccurrence(new Integer(i)));
627                assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
628            }
629            assertTrue(q.isEmpty());
630        }
631    
632        /**
633         * removeLastOccurrence(x) removes x and returns true if present
634         */
635        public void testRemoveLastOccurrence() {
636            LinkedList q = populatedQueue(SIZE);
637            for (int i = 1; i < SIZE; i+=2) {
638                assertTrue(q.removeLastOccurrence(new Integer(i)));
639            }
640            for (int i = 0; i < SIZE; i+=2) {
641                assertTrue(q.removeLastOccurrence(new Integer(i)));
642                assertFalse(q.removeLastOccurrence(new Integer(i+1)));
643            }
644            assertTrue(q.isEmpty());
645        }
646    
647  }  }

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.9

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8