--- jsr166/src/test/tck/PriorityQueueTest.java	2009/11/02 20:28:31	1.9
+++ jsr166/src/test/tck/PriorityQueueTest.java	2021/01/26 13:33:06	1.48
@@ -1,47 +1,70 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  * Other contributors include Andrew Wright, Jeffrey Hayes,
  * Pat Fisher, Mike Judd.
  */
 
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
-import java.io.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+import junit.framework.Test;
 
 public class PriorityQueueTest extends JSR166TestCase {
     public static void main(String[] args) {
-	junit.textui.TestRunner.run (suite());
+        main(suite(), args);
     }
     public static Test suite() {
-	return new TestSuite(PriorityQueueTest.class);
+        class Implementation implements CollectionImplementation {
+            public Class<?> klazz() { return PriorityQueue.class; }
+            public Collection emptyCollection() { return new PriorityQueue(); }
+            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
+            public boolean isConcurrent() { return false; }
+            public boolean permitsNulls() { return false; }
+        }
+        class ComparatorImplementation implements CollectionImplementation {
+            public Class<?> klazz() { return PriorityQueue.class; }
+            @SuppressWarnings("unchecked")
+            public Collection emptyCollection() {
+                return new PriorityQueue(new MyReverseComparator());
+            }
+            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
+            public boolean isConcurrent() { return false; }
+            public boolean permitsNulls() { return false; }
+        }
+        return newTestSuite(
+            PriorityQueueTest.class,
+            CollectionTest.testSuite(new Implementation()),
+            CollectionTest.testSuite(new ComparatorImplementation()));
     }
 
-    static class MyReverseComparator implements Comparator {
+    static class MyReverseComparator implements Comparator, java.io.Serializable {
+        @SuppressWarnings("unchecked")
         public int compare(Object x, Object y) {
-            int i = ((Integer)x).intValue();
-            int j = ((Integer)y).intValue();
-            if (i < j) return 1;
-            if (i > j) return -1;
-            return 0;
+            return ((Comparable)y).compareTo(x);
         }
     }
 
     /**
-     * Create a queue of given size containing consecutive
-     * Integers 0 ... n.
+     * Returns a new queue of given size containing consecutive
+     * Items 0 ... n - 1.
      */
-    private PriorityQueue populatedQueue(int n) {
-        PriorityQueue q = new PriorityQueue(n);
+    private static PriorityQueue<Item> populatedQueue(int n) {
+        PriorityQueue<Item> q = new PriorityQueue<>(n);
         assertTrue(q.isEmpty());
-	for(int i = n-1; i >= 0; i-=2)
-	    assertTrue(q.offer(new Integer(i)));
-	for(int i = (n & 1); i < n; i+=2)
-	    assertTrue(q.offer(new Integer(i)));
+        for (int i = n - 1; i >= 0; i -= 2)
+            mustOffer(q, i);
+        for (int i = (n & 1); i < n; i += 2)
+            mustOffer(q, i);
         assertFalse(q.isEmpty());
-	assertEquals(n, q.size());
+        mustEqual(n, q.size());
+        mustEqual(0, q.peek());
         return q;
     }
 
@@ -49,18 +72,17 @@ public class PriorityQueueTest extends J
      * A new queue has unbounded capacity
      */
     public void testConstructor1() {
-        assertEquals(0, new PriorityQueue(SIZE).size());
+        mustEqual(0, new PriorityQueue<Item>(SIZE).size());
     }
 
     /**
-     * Constructor throws IAE if  capacity argument nonpositive
+     * Constructor throws IllegalArgumentException if capacity argument nonpositive
      */
     public void testConstructor2() {
         try {
-            PriorityQueue q = new PriorityQueue(0);
+            new PriorityQueue<Item>(0);
             shouldThrow();
-        }
-        catch (IllegalArgumentException success) {}
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -68,10 +90,9 @@ public class PriorityQueueTest extends J
      */
     public void testConstructor3() {
         try {
-            PriorityQueue q = new PriorityQueue((Collection)null);
+            new PriorityQueue<Item>((Collection<Item>)null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -79,69 +100,56 @@ public class PriorityQueueTest extends J
      */
     public void testConstructor4() {
         try {
-            Integer[] ints = new Integer[SIZE];
-            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
+            new PriorityQueue<Item>(Arrays.asList(new Item[SIZE]));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Initializing from Collection with some null elements throws NPE
      */
     public void testConstructor5() {
+        Item[] items = new Item[2];
+        items[0] = zero;
         try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new Integer(i);
-            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
+            new PriorityQueue<Item>(Arrays.asList(items));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Queue contains all elements of collection used to initialize
      */
     public void testConstructor6() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+        Item[] items = defaultItems;
+        PriorityQueue<Item> q = new PriorityQueue<Item>(Arrays.asList(items));
+        for (int i = 0; i < SIZE; ++i)
+            mustEqual(items[i], q.poll());
     }
 
     /**
      * The comparator used in constructor is used
      */
     public void testConstructor7() {
-        try {
-            MyReverseComparator cmp = new MyReverseComparator();
-            PriorityQueue q = new PriorityQueue(SIZE, cmp);
-            assertEquals(cmp, q.comparator());
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            q.addAll(Arrays.asList(ints));
-            for (int i = SIZE-1; i >= 0; --i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+        MyReverseComparator cmp = new MyReverseComparator();
+        @SuppressWarnings("unchecked")
+        PriorityQueue<Item> q = new PriorityQueue<Item>(SIZE, cmp);
+        assertEquals(cmp, q.comparator());
+        Item[] items = seqItems(SIZE);
+        q.addAll(Arrays.asList(items));
+        for (int i = SIZE - 1; i >= 0; --i)
+            mustEqual(items[i], q.poll());
     }
 
     /**
      * isEmpty is true before add, false after
      */
     public void testEmpty() {
-        PriorityQueue q = new PriorityQueue(2);
+        PriorityQueue<Item> q = new PriorityQueue<Item>(2);
         assertTrue(q.isEmpty());
-        q.add(new Integer(1));
+        q.add(one);
         assertFalse(q.isEmpty());
-        q.add(new Integer(2));
+        q.add(two);
         q.remove();
         q.remove();
         assertTrue(q.isEmpty());
@@ -151,14 +159,14 @@ public class PriorityQueueTest extends J
      * size changes when elements added and removed
      */
     public void testSize() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(SIZE-i, q.size());
+            mustEqual(SIZE - i, q.size());
             q.remove();
         }
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            q.add(new Integer(i));
+            mustEqual(i, q.size());
+            mustAdd(q, i);
         }
     }
 
@@ -166,29 +174,29 @@ public class PriorityQueueTest extends J
      * offer(null) throws NPE
      */
     public void testOfferNull() {
-	try {
-            PriorityQueue q = new PriorityQueue(1);
+        PriorityQueue<Item> q = new PriorityQueue<Item>(1);
+        try {
             q.offer(null);
             shouldThrow();
-        } catch (NullPointerException success) { }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * add(null) throws NPE
      */
     public void testAddNull() {
-	try {
-            PriorityQueue q = new PriorityQueue(1);
+        PriorityQueue<Item> q = new PriorityQueue<Item>(1);
+        try {
             q.add(null);
             shouldThrow();
-        } catch (NullPointerException success) { }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Offer of comparable element succeeds
      */
     public void testOffer() {
-        PriorityQueue q = new PriorityQueue(1);
+        PriorityQueue<Item> q = new PriorityQueue<Item>(1);
         assertTrue(q.offer(zero));
         assertTrue(q.offer(one));
     }
@@ -197,24 +205,25 @@ public class PriorityQueueTest extends J
      * Offer of non-Comparable throws CCE
      */
     public void testOfferNonComparable() {
+        PriorityQueue<Object> q = new PriorityQueue<Object>(1);
         try {
-            PriorityQueue q = new PriorityQueue(1);
-            q.offer(new Object());
-            q.offer(new Object());
             q.offer(new Object());
             shouldThrow();
+        } catch (ClassCastException success) {
+            assertTrue(q.isEmpty());
+            mustEqual(0, q.size());
+            assertNull(q.poll());
         }
-        catch(ClassCastException success) {}
     }
 
     /**
      * add of comparable succeeds
      */
     public void testAdd() {
-        PriorityQueue q = new PriorityQueue(SIZE);
+        PriorityQueue<Item> q = new PriorityQueue<Item>(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            assertTrue(q.add(new Integer(i)));
+            mustEqual(i, q.size());
+            mustAdd(q, i);
         }
     }
 
@@ -222,126 +231,124 @@ public class PriorityQueueTest extends J
      * addAll(null) throws NPE
      */
     public void testAddAll1() {
+        PriorityQueue<Item> q = new PriorityQueue<Item>(1);
         try {
-            PriorityQueue q = new PriorityQueue(1);
             q.addAll(null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
+
     /**
      * addAll of a collection with null elements throws NPE
      */
     public void testAddAll2() {
+        PriorityQueue<Item> q = new PriorityQueue<Item>(SIZE);
         try {
-            PriorityQueue q = new PriorityQueue(SIZE);
-            Integer[] ints = new Integer[SIZE];
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(new Item[SIZE]));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
+
     /**
      * addAll of a collection with any null elements throws NPE after
      * possibly adding some elements
      */
     public void testAddAll3() {
+        PriorityQueue<Item> q = new PriorityQueue<Item>(SIZE);
+        Item[] items = new Item[2];
+        items[0] = zero;
         try {
-            PriorityQueue q = new PriorityQueue(SIZE);
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new Integer(i);
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(items));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Queue contains all elements of successful addAll
      */
     public void testAddAll5() {
-        try {
-            Integer[] empty = new Integer[0];
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(SIZE-1-i);
-            PriorityQueue q = new PriorityQueue(SIZE);
-            assertFalse(q.addAll(Arrays.asList(empty)));
-            assertTrue(q.addAll(Arrays.asList(ints)));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(new Integer(i), q.poll());
-        }
-        finally {}
+        Item[] empty = new Item[0];
+        Item[] items = new Item[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            items[i] = itemFor(SIZE - 1 - i);
+        PriorityQueue<Item> q = new PriorityQueue<Item>(SIZE);
+        assertFalse(q.addAll(Arrays.asList(empty)));
+        assertTrue(q.addAll(Arrays.asList(items)));
+        for (int i = 0; i < SIZE; ++i)
+            mustEqual(i, q.poll());
     }
 
     /**
      * poll succeeds unless empty
      */
     public void testPoll() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.poll()).intValue());
+            mustEqual(i, q.poll());
         }
-	assertNull(q.poll());
+        assertNull(q.poll());
     }
 
     /**
      * peek returns next element, or null if empty
      */
     public void testPeek() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.peek()).intValue());
-            q.poll();
+            mustEqual(i, q.peek());
+            mustEqual(i, q.poll());
             assertTrue(q.peek() == null ||
-                       i != ((Integer)q.peek()).intValue());
+                       !q.peek().equals(i));
         }
-	assertNull(q.peek());
+        assertNull(q.peek());
     }
 
     /**
      * element returns next element, or throws NSEE if empty
      */
     public void testElement() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.element()).intValue());
-            q.poll();
+            mustEqual(i, q.element());
+            mustEqual(i, q.poll());
         }
         try {
             q.element();
             shouldThrow();
-        }
-        catch (NoSuchElementException success) {}
+        } catch (NoSuchElementException success) {}
     }
 
     /**
      * remove removes next element, or throws NSEE if empty
      */
     public void testRemove() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.remove()).intValue());
+            mustEqual(i, q.remove());
         }
         try {
             q.remove();
             shouldThrow();
-        } catch (NoSuchElementException success){
-	}
+        } catch (NoSuchElementException success) {}
     }
 
     /**
      * remove(x) removes x and returns true if present
      */
     public void testRemoveElement() {
-        PriorityQueue q = populatedQueue(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
-            assertTrue(q.remove(new Integer(i)));
-        }
-        for (int i = 0; i < SIZE; i+=2) {
-            assertTrue(q.remove(new Integer(i)));
-            assertFalse(q.remove(new Integer(i+1)));
+        PriorityQueue<Item> q = populatedQueue(SIZE);
+        for (int i = 1; i < SIZE; i += 2) {
+            mustContain(q, i);
+            mustRemove(q, i);
+            mustNotContain(q, i);
+            mustContain(q, i - 1);
+        }
+        for (int i = 0; i < SIZE; i += 2) {
+            mustContain(q, i);
+            mustRemove(q, i);
+            mustNotContain(q, i);
+            mustNotRemove(q, i + 1);
+            mustNotContain(q, i + 1);
         }
         assertTrue(q.isEmpty());
     }
@@ -350,11 +357,11 @@ public class PriorityQueueTest extends J
      * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertTrue(q.contains(new Integer(i)));
+            mustContain(q, i);
             q.poll();
-            assertFalse(q.contains(new Integer(i)));
+            mustNotContain(q, i);
         }
     }
 
@@ -362,11 +369,11 @@ public class PriorityQueueTest extends J
      * clear removes all elements
      */
     public void testClear() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         q.clear();
         assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        q.add(new Integer(1));
+        mustEqual(0, q.size());
+        q.add(one);
         assertFalse(q.isEmpty());
         q.clear();
         assertTrue(q.isEmpty());
@@ -376,12 +383,12 @@ public class PriorityQueueTest extends J
      * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
-        PriorityQueue q = populatedQueue(SIZE);
-        PriorityQueue p = new PriorityQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
+        PriorityQueue<Item> p = new PriorityQueue<Item>(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
-            p.add(new Integer(i));
+            mustAdd(p, i);
         }
         assertTrue(p.containsAll(q));
     }
@@ -390,8 +397,8 @@ public class PriorityQueueTest extends J
      * retainAll(c) retains only those elements of c and reports true if changed
      */
     public void testRetainAll() {
-        PriorityQueue q = populatedQueue(SIZE);
-        PriorityQueue p = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
+        PriorityQueue<Item> p = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             boolean changed = q.retainAll(p);
             if (i == 0)
@@ -400,7 +407,7 @@ public class PriorityQueueTest extends J
                 assertTrue(changed);
 
             assertTrue(q.containsAll(p));
-            assertEquals(SIZE-i, q.size());
+            mustEqual(SIZE - i, q.size());
             p.remove();
         }
     }
@@ -410,13 +417,12 @@ public class PriorityQueueTest extends J
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
-            PriorityQueue q = populatedQueue(SIZE);
-            PriorityQueue p = populatedQueue(i);
+            PriorityQueue<Item> q = populatedQueue(SIZE);
+            PriorityQueue<Item> p = populatedQueue(i);
             assertTrue(q.removeAll(p));
-            assertEquals(SIZE-i, q.size());
+            mustEqual(SIZE - i, q.size());
             for (int j = 0; j < i; ++j) {
-                Integer I = (Integer)(p.remove());
-                assertFalse(q.contains(I));
+                mustNotContain(q, p.remove());
             }
         }
     }
@@ -425,89 +431,92 @@ public class PriorityQueueTest extends J
      * toArray contains all elements
      */
     public void testToArray() {
-        PriorityQueue q = populatedQueue(SIZE);
-	Object[] o = q.toArray();
-        Arrays.sort(o);
-	for(int i = 0; i < o.length; i++)
-	    assertEquals(o[i], q.poll());
+        PriorityQueue<Item> q = populatedQueue(SIZE);
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        Arrays.sort(a);
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
      * toArray(a) contains all elements
      */
     public void testToArray2() {
-        PriorityQueue q = populatedQueue(SIZE);
-	Integer[] ints = new Integer[SIZE];
-	ints = (Integer[])q.toArray(ints);
-        Arrays.sort(ints);
-        for(int i = 0; i < ints.length; i++)
-            assertEquals(ints[i], q.poll());
+        PriorityQueue<Item> q = populatedQueue(SIZE);
+        Item[] items = new Item[SIZE];
+        Item[] array = q.toArray(items);
+        assertSame(items, array);
+        Arrays.sort(items);
+        for (Item o : items)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
      * iterator iterates through all elements
      */
     public void testIterator() {
-        PriorityQueue q = populatedQueue(SIZE);
-        int i = 0;
-	Iterator it = q.iterator();
-        while(it.hasNext()) {
-            assertTrue(q.contains(it.next()));
-            ++i;
-        }
-        assertEquals(i, SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
+        Iterator<? extends Item> it = q.iterator();
+        int i;
+        for (i = 0; it.hasNext(); i++)
+            mustContain(q, it.next());
+        mustEqual(i, SIZE);
+        assertIteratorExhausted(it);
+    }
+
+    /**
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(new PriorityQueue<Item>().iterator());
     }
 
     /**
      * iterator.remove removes current element
      */
-    public void testIteratorRemove () {
-        final PriorityQueue q = new PriorityQueue(3);
-        q.add(new Integer(2));
-        q.add(new Integer(1));
-        q.add(new Integer(3));
+    public void testIteratorRemove() {
+        final PriorityQueue<Item> q = new PriorityQueue<Item>(3);
+        q.add(two);
+        q.add(one);
+        q.add(three);
 
-        Iterator it = q.iterator();
+        Iterator<? extends Item> it = q.iterator();
         it.next();
         it.remove();
 
         it = q.iterator();
-        assertEquals(it.next(), new Integer(2));
-        assertEquals(it.next(), new Integer(3));
+        mustEqual(it.next(), two);
+        mustEqual(it.next(), three);
         assertFalse(it.hasNext());
     }
 
-
     /**
      * toString contains toStrings of elements
      */
     public void testToString() {
-        PriorityQueue q = populatedQueue(SIZE);
+        PriorityQueue<Item> q = populatedQueue(SIZE);
         String s = q.toString();
         for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
+            assertTrue(s.contains(String.valueOf(i)));
         }
     }
 
     /**
-     * A deserialized serialized queue has same elements
+     * A deserialized/reserialized queue has same elements
      */
-    public void testSerialization() {
-        PriorityQueue q = populatedQueue(SIZE);
-        try {
-            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
-            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
-            out.writeObject(q);
-            out.close();
+    public void testSerialization() throws Exception {
+        Queue<Item> x = populatedQueue(SIZE);
+        Queue<Item> y = serialClone(x);
 
-            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
-            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
-            PriorityQueue r = (PriorityQueue)in.readObject();
-            assertEquals(q.size(), r.size());
-            while (!q.isEmpty())
-                assertEquals(q.remove(), r.remove());
-        } catch(Exception e){
-            unexpectedException();
+        assertNotSame(x, y);
+        mustEqual(x.size(), y.size());
+        while (!x.isEmpty()) {
+            assertFalse(y.isEmpty());
+            mustEqual(x.remove(), y.remove());
         }
+        assertTrue(y.isEmpty());
     }
 }