ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadPoolExecutorTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.112 by jsr166, Thu Oct 8 03:08:38 2015 UTC vs.
Revision 1.121 by jsr166, Sat Jul 15 18:28:08 2017 UTC

# Line 11 | Line 11 | import static java.util.concurrent.TimeU
11   import static java.util.concurrent.TimeUnit.SECONDS;
12  
13   import java.util.ArrayList;
14 + import java.util.Collection;
15 + import java.util.Collections;
16   import java.util.List;
17   import java.util.concurrent.ArrayBlockingQueue;
18   import java.util.concurrent.BlockingQueue;
# Line 18 | Line 20 | import java.util.concurrent.Callable;
20   import java.util.concurrent.CancellationException;
21   import java.util.concurrent.CountDownLatch;
22   import java.util.concurrent.ExecutionException;
21 – import java.util.concurrent.Executors;
23   import java.util.concurrent.ExecutorService;
24   import java.util.concurrent.Future;
25   import java.util.concurrent.FutureTask;
# Line 28 | Line 29 | import java.util.concurrent.RejectedExec
29   import java.util.concurrent.SynchronousQueue;
30   import java.util.concurrent.ThreadFactory;
31   import java.util.concurrent.ThreadPoolExecutor;
32 < import java.util.concurrent.TimeUnit;
32 > import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
33 > import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
34 > import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
35 > import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
36   import java.util.concurrent.atomic.AtomicInteger;
37 + import java.util.concurrent.atomic.AtomicReference;
38  
39   import junit.framework.Test;
40   import junit.framework.TestSuite;
# Line 92 | Line 97 | public class ThreadPoolExecutorTest exte
97              final Runnable task = new CheckedRunnable() {
98                  public void realRun() { done.countDown(); }};
99              p.execute(task);
100 <            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
100 >            await(done);
101          }
102      }
103  
# Line 186 | Line 191 | public class ThreadPoolExecutorTest exte
191                  public void realRun() throws InterruptedException {
192                      threadStarted.countDown();
193                      assertEquals(0, p.getCompletedTaskCount());
194 <                    threadProceed.await();
194 >                    await(threadProceed);
195                      threadDone.countDown();
196                  }});
197              await(threadStarted);
198              assertEquals(0, p.getCompletedTaskCount());
199              threadProceed.countDown();
200 <            threadDone.await();
200 >            await(threadDone);
201              long startTime = System.nanoTime();
202              while (p.getCompletedTaskCount() != 1) {
203                  if (millisElapsedSince(startTime) > LONG_DELAY_MS)
# Line 276 | Line 281 | public class ThreadPoolExecutorTest exte
281      }
282  
283      /**
284 +     * The default rejected execution handler is AbortPolicy.
285 +     */
286 +    public void testDefaultRejectedExecutionHandler() {
287 +        final ThreadPoolExecutor p =
288 +            new ThreadPoolExecutor(1, 2,
289 +                                   LONG_DELAY_MS, MILLISECONDS,
290 +                                   new ArrayBlockingQueue<Runnable>(10));
291 +        try (PoolCleaner cleaner = cleaner(p)) {
292 +            assertTrue(p.getRejectedExecutionHandler() instanceof AbortPolicy);
293 +        }
294 +    }
295 +
296 +    /**
297       * getRejectedExecutionHandler returns handler in constructor if not set
298       */
299      public void testGetRejectedExecutionHandler() {
# Line 458 | Line 476 | public class ThreadPoolExecutorTest exte
476              assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
477              assertFalse(p.awaitTermination(-1L, NANOSECONDS));
478              assertFalse(p.awaitTermination(-1L, MILLISECONDS));
479 <            assertFalse(p.awaitTermination(0L, NANOSECONDS));
480 <            assertFalse(p.awaitTermination(0L, MILLISECONDS));
479 >            assertFalse(p.awaitTermination(randomExpiredTimeout(),
480 >                                           randomTimeUnit()));
481              long timeoutNanos = 999999L;
482              long startTime = System.nanoTime();
483              assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
# Line 537 | Line 555 | public class ThreadPoolExecutorTest exte
555       */
556      public void testGetQueue() throws InterruptedException {
557          final CountDownLatch done = new CountDownLatch(1);
558 <        final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
558 >        final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
559          final ThreadPoolExecutor p =
560              new ThreadPoolExecutor(1, 1,
561                                     LONG_DELAY_MS, MILLISECONDS,
# Line 569 | Line 587 | public class ThreadPoolExecutorTest exte
587       */
588      public void testRemove() throws InterruptedException {
589          final CountDownLatch done = new CountDownLatch(1);
590 <        BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
590 >        BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
591          final ThreadPoolExecutor p =
592              new ThreadPoolExecutor(1, 1,
593                                     LONG_DELAY_MS, MILLISECONDS,
# Line 604 | Line 622 | public class ThreadPoolExecutorTest exte
622      public void testPurge() throws InterruptedException {
623          final CountDownLatch threadStarted = new CountDownLatch(1);
624          final CountDownLatch done = new CountDownLatch(1);
625 <        final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
625 >        final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
626          final ThreadPoolExecutor p =
627              new ThreadPoolExecutor(1, 1,
628                                     LONG_DELAY_MS, MILLISECONDS,
# Line 1113 | Line 1131 | public class ThreadPoolExecutorTest exte
1131                      await(done);
1132                  }};
1133              for (int i = 0; i < 2; ++i)
1134 <                p.submit(Executors.callable(task));
1134 >                p.execute(task);
1135              for (int i = 0; i < 2; ++i) {
1136                  try {
1137                      p.execute(task);
# Line 1133 | Line 1151 | public class ThreadPoolExecutorTest exte
1151                                     LONG_DELAY_MS,
1152                                     MILLISECONDS,
1153                                     new ArrayBlockingQueue<Runnable>(1),
1154 <                                   new ThreadPoolExecutor.CallerRunsPolicy());
1154 >                                   new CallerRunsPolicy());
1155          try (PoolCleaner cleaner = cleaner(p)) {
1156              final CountDownLatch done = new CountDownLatch(1);
1157              Runnable blocker = new CheckedRunnable() {
# Line 1165 | Line 1183 | public class ThreadPoolExecutorTest exte
1183              new ThreadPoolExecutor(1, 1,
1184                            LONG_DELAY_MS, MILLISECONDS,
1185                            new ArrayBlockingQueue<Runnable>(1),
1186 <                          new ThreadPoolExecutor.DiscardPolicy());
1186 >                          new DiscardPolicy());
1187          try (PoolCleaner cleaner = cleaner(p, done)) {
1188              p.execute(awaiter(done));
1189  
# Line 1191 | Line 1209 | public class ThreadPoolExecutorTest exte
1209              new ThreadPoolExecutor(1, 1,
1210                                     LONG_DELAY_MS, MILLISECONDS,
1211                                     new ArrayBlockingQueue<Runnable>(1),
1212 <                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1212 >                                   new DiscardOldestPolicy());
1213          try (PoolCleaner cleaner = cleaner(p, done)) {
1214              assertEquals(LatchAwaiter.NEW, r1.state);
1215              assertEquals(LatchAwaiter.NEW, r2.state);
# Line 1229 | Line 1247 | public class ThreadPoolExecutorTest exte
1247       * execute using CallerRunsPolicy drops task on shutdown
1248       */
1249      public void testCallerRunsOnShutdown() {
1250 <        RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
1250 >        RejectedExecutionHandler h = new CallerRunsPolicy();
1251          final ThreadPoolExecutor p =
1252              new ThreadPoolExecutor(1, 1,
1253                                     LONG_DELAY_MS, MILLISECONDS,
# Line 1251 | Line 1269 | public class ThreadPoolExecutorTest exte
1269              new ThreadPoolExecutor(1, 1,
1270                                     LONG_DELAY_MS, MILLISECONDS,
1271                                     new ArrayBlockingQueue<Runnable>(1),
1272 <                                   new ThreadPoolExecutor.DiscardPolicy());
1272 >                                   new DiscardPolicy());
1273  
1274          try { p.shutdown(); } catch (SecurityException ok) { return; }
1275          try (PoolCleaner cleaner = cleaner(p)) {
# Line 1269 | Line 1287 | public class ThreadPoolExecutorTest exte
1287              new ThreadPoolExecutor(1, 1,
1288                                     LONG_DELAY_MS, MILLISECONDS,
1289                                     new ArrayBlockingQueue<Runnable>(1),
1290 <                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1290 >                                   new DiscardOldestPolicy());
1291  
1292          try { p.shutdown(); } catch (SecurityException ok) { return; }
1293          try (PoolCleaner cleaner = cleaner(p)) {
# Line 1483 | Line 1501 | public class ThreadPoolExecutorTest exte
1501      }
1502  
1503      /**
1504 <     * invokeAny(empty collection) throws IAE
1504 >     * invokeAny(empty collection) throws IllegalArgumentException
1505       */
1506      public void testInvokeAny2() throws Exception {
1507          final ExecutorService e =
# Line 1508 | Line 1526 | public class ThreadPoolExecutorTest exte
1526                                     LONG_DELAY_MS, MILLISECONDS,
1527                                     new ArrayBlockingQueue<Runnable>(10));
1528          try (PoolCleaner cleaner = cleaner(e)) {
1529 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1529 >            List<Callable<String>> l = new ArrayList<>();
1530              l.add(latchAwaitingStringTask(latch));
1531              l.add(null);
1532              try {
# Line 1528 | Line 1546 | public class ThreadPoolExecutorTest exte
1546                                     LONG_DELAY_MS, MILLISECONDS,
1547                                     new ArrayBlockingQueue<Runnable>(10));
1548          try (PoolCleaner cleaner = cleaner(e)) {
1549 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1549 >            List<Callable<String>> l = new ArrayList<>();
1550              l.add(new NPETask());
1551              try {
1552                  e.invokeAny(l);
# Line 1548 | Line 1566 | public class ThreadPoolExecutorTest exte
1566                                     LONG_DELAY_MS, MILLISECONDS,
1567                                     new ArrayBlockingQueue<Runnable>(10));
1568          try (PoolCleaner cleaner = cleaner(e)) {
1569 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1569 >            List<Callable<String>> l = new ArrayList<>();
1570              l.add(new StringTask());
1571              l.add(new StringTask());
1572              String result = e.invokeAny(l);
# Line 1573 | Line 1591 | public class ThreadPoolExecutorTest exte
1591      }
1592  
1593      /**
1594 <     * invokeAll(empty collection) returns empty collection
1594 >     * invokeAll(empty collection) returns empty list
1595       */
1596      public void testInvokeAll2() throws InterruptedException {
1597          final ExecutorService e =
1598              new ThreadPoolExecutor(2, 2,
1599                                     LONG_DELAY_MS, MILLISECONDS,
1600                                     new ArrayBlockingQueue<Runnable>(10));
1601 +        final Collection<Callable<String>> emptyCollection
1602 +            = Collections.emptyList();
1603          try (PoolCleaner cleaner = cleaner(e)) {
1604 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1604 >            List<Future<String>> r = e.invokeAll(emptyCollection);
1605              assertTrue(r.isEmpty());
1606          }
1607      }
# Line 1595 | Line 1615 | public class ThreadPoolExecutorTest exte
1615                                     LONG_DELAY_MS, MILLISECONDS,
1616                                     new ArrayBlockingQueue<Runnable>(10));
1617          try (PoolCleaner cleaner = cleaner(e)) {
1618 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1618 >            List<Callable<String>> l = new ArrayList<>();
1619              l.add(new StringTask());
1620              l.add(null);
1621              try {
# Line 1614 | Line 1634 | public class ThreadPoolExecutorTest exte
1634                                     LONG_DELAY_MS, MILLISECONDS,
1635                                     new ArrayBlockingQueue<Runnable>(10));
1636          try (PoolCleaner cleaner = cleaner(e)) {
1637 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1637 >            List<Callable<String>> l = new ArrayList<>();
1638              l.add(new NPETask());
1639              List<Future<String>> futures = e.invokeAll(l);
1640              assertEquals(1, futures.size());
# Line 1636 | Line 1656 | public class ThreadPoolExecutorTest exte
1656                                     LONG_DELAY_MS, MILLISECONDS,
1657                                     new ArrayBlockingQueue<Runnable>(10));
1658          try (PoolCleaner cleaner = cleaner(e)) {
1659 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1659 >            List<Callable<String>> l = new ArrayList<>();
1660              l.add(new StringTask());
1661              l.add(new StringTask());
1662              List<Future<String>> futures = e.invokeAll(l);
# Line 1656 | Line 1676 | public class ThreadPoolExecutorTest exte
1676                                     new ArrayBlockingQueue<Runnable>(10));
1677          try (PoolCleaner cleaner = cleaner(e)) {
1678              try {
1679 <                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1679 >                e.invokeAny(null, randomTimeout(), randomTimeUnit());
1680                  shouldThrow();
1681              } catch (NullPointerException success) {}
1682          }
# Line 1671 | Line 1691 | public class ThreadPoolExecutorTest exte
1691                                     LONG_DELAY_MS, MILLISECONDS,
1692                                     new ArrayBlockingQueue<Runnable>(10));
1693          try (PoolCleaner cleaner = cleaner(e)) {
1694 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1694 >            List<Callable<String>> l = new ArrayList<>();
1695              l.add(new StringTask());
1696              try {
1697 <                e.invokeAny(l, MEDIUM_DELAY_MS, null);
1697 >                e.invokeAny(l, randomTimeout(), null);
1698                  shouldThrow();
1699              } catch (NullPointerException success) {}
1700          }
1701      }
1702  
1703      /**
1704 <     * timed invokeAny(empty collection) throws IAE
1704 >     * timed invokeAny(empty collection) throws IllegalArgumentException
1705       */
1706      public void testTimedInvokeAny2() throws Exception {
1707          final ExecutorService e =
# Line 1691 | Line 1711 | public class ThreadPoolExecutorTest exte
1711          try (PoolCleaner cleaner = cleaner(e)) {
1712              try {
1713                  e.invokeAny(new ArrayList<Callable<String>>(),
1714 <                            MEDIUM_DELAY_MS, MILLISECONDS);
1714 >                            randomTimeout(), randomTimeUnit());
1715                  shouldThrow();
1716              } catch (IllegalArgumentException success) {}
1717          }
1718      }
1719  
1720      /**
1721 <     * timed invokeAny(c) throws NPE if c has null elements
1721 >     * timed invokeAny(c) throws NullPointerException if c has null elements
1722       */
1723      public void testTimedInvokeAny3() throws Exception {
1724          final CountDownLatch latch = new CountDownLatch(1);
# Line 1707 | Line 1727 | public class ThreadPoolExecutorTest exte
1727                                     LONG_DELAY_MS, MILLISECONDS,
1728                                     new ArrayBlockingQueue<Runnable>(10));
1729          try (PoolCleaner cleaner = cleaner(e)) {
1730 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1730 >            List<Callable<String>> l = new ArrayList<>();
1731              l.add(latchAwaitingStringTask(latch));
1732              l.add(null);
1733              try {
1734 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1734 >                e.invokeAny(l, randomTimeout(), randomTimeUnit());
1735                  shouldThrow();
1736              } catch (NullPointerException success) {}
1737              latch.countDown();
# Line 1728 | Line 1748 | public class ThreadPoolExecutorTest exte
1748                                     new ArrayBlockingQueue<Runnable>(10));
1749          try (PoolCleaner cleaner = cleaner(e)) {
1750              long startTime = System.nanoTime();
1751 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1751 >            List<Callable<String>> l = new ArrayList<>();
1752              l.add(new NPETask());
1753              try {
1754                  e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
# Line 1750 | Line 1770 | public class ThreadPoolExecutorTest exte
1770                                     new ArrayBlockingQueue<Runnable>(10));
1771          try (PoolCleaner cleaner = cleaner(e)) {
1772              long startTime = System.nanoTime();
1773 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1773 >            List<Callable<String>> l = new ArrayList<>();
1774              l.add(new StringTask());
1775              l.add(new StringTask());
1776              String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
# Line 1769 | Line 1789 | public class ThreadPoolExecutorTest exte
1789                                     new ArrayBlockingQueue<Runnable>(10));
1790          try (PoolCleaner cleaner = cleaner(e)) {
1791              try {
1792 <                e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1792 >                e.invokeAll(null, randomTimeout(), randomTimeUnit());
1793                  shouldThrow();
1794              } catch (NullPointerException success) {}
1795          }
# Line 1784 | Line 1804 | public class ThreadPoolExecutorTest exte
1804                                     LONG_DELAY_MS, MILLISECONDS,
1805                                     new ArrayBlockingQueue<Runnable>(10));
1806          try (PoolCleaner cleaner = cleaner(e)) {
1807 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1807 >            List<Callable<String>> l = new ArrayList<>();
1808              l.add(new StringTask());
1809              try {
1810 <                e.invokeAll(l, MEDIUM_DELAY_MS, null);
1810 >                e.invokeAll(l, randomTimeout(), null);
1811                  shouldThrow();
1812              } catch (NullPointerException success) {}
1813          }
1814      }
1815  
1816      /**
1817 <     * timed invokeAll(empty collection) returns empty collection
1817 >     * timed invokeAll(empty collection) returns empty list
1818       */
1819      public void testTimedInvokeAll2() throws InterruptedException {
1820          final ExecutorService e =
1821              new ThreadPoolExecutor(2, 2,
1822                                     LONG_DELAY_MS, MILLISECONDS,
1823                                     new ArrayBlockingQueue<Runnable>(10));
1824 +        final Collection<Callable<String>> emptyCollection
1825 +            = Collections.emptyList();
1826          try (PoolCleaner cleaner = cleaner(e)) {
1827 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1828 <                                                 MEDIUM_DELAY_MS, MILLISECONDS);
1827 >            List<Future<String>> r =
1828 >                e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1829              assertTrue(r.isEmpty());
1830          }
1831      }
# Line 1817 | Line 1839 | public class ThreadPoolExecutorTest exte
1839                                     LONG_DELAY_MS, MILLISECONDS,
1840                                     new ArrayBlockingQueue<Runnable>(10));
1841          try (PoolCleaner cleaner = cleaner(e)) {
1842 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1842 >            List<Callable<String>> l = new ArrayList<>();
1843              l.add(new StringTask());
1844              l.add(null);
1845              try {
1846 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1846 >                e.invokeAll(l, randomTimeout(), randomTimeUnit());
1847                  shouldThrow();
1848              } catch (NullPointerException success) {}
1849          }
# Line 1836 | Line 1858 | public class ThreadPoolExecutorTest exte
1858                                     LONG_DELAY_MS, MILLISECONDS,
1859                                     new ArrayBlockingQueue<Runnable>(10));
1860          try (PoolCleaner cleaner = cleaner(e)) {
1861 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1861 >            List<Callable<String>> l = new ArrayList<>();
1862              l.add(new NPETask());
1863              List<Future<String>> futures =
1864                  e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
# Line 1859 | Line 1881 | public class ThreadPoolExecutorTest exte
1881                                     LONG_DELAY_MS, MILLISECONDS,
1882                                     new ArrayBlockingQueue<Runnable>(10));
1883          try (PoolCleaner cleaner = cleaner(e)) {
1884 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1884 >            List<Callable<String>> l = new ArrayList<>();
1885              l.add(new StringTask());
1886              l.add(new StringTask());
1887              List<Future<String>> futures =
# Line 1929 | Line 1951 | public class ThreadPoolExecutorTest exte
1951                      public void realRun() {
1952                          done.countDown();
1953                      }});
1954 <            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1954 >            await(done);
1955          }
1956      }
1957  
# Line 2022 | Line 2044 | public class ThreadPoolExecutorTest exte
2044                  }
2045              }
2046              // enough time to run all tasks
2047 <            assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
2047 >            await(done, nTasks * SHORT_DELAY_MS);
2048          }
2049      }
2050  
# Line 2063 | Line 2085 | public class ThreadPoolExecutorTest exte
2085          }
2086      }
2087  
2088 +    public void testAbortPolicy() {
2089 +        final RejectedExecutionHandler handler = new AbortPolicy();
2090 +        final ThreadPoolExecutor p =
2091 +            new ThreadPoolExecutor(1, 1,
2092 +                                   LONG_DELAY_MS, MILLISECONDS,
2093 +                                   new ArrayBlockingQueue<Runnable>(10));
2094 +        final TrackedNoOpRunnable r = new TrackedNoOpRunnable();
2095 +        try {
2096 +            handler.rejectedExecution(r, p);
2097 +            shouldThrow();
2098 +        } catch (RejectedExecutionException success) {}
2099 +        assertFalse(r.done);
2100 +        assertEquals(0, p.getTaskCount());
2101 +        assertTrue(p.getQueue().isEmpty());
2102 +    }
2103 +
2104 +    public void testCallerRunsPolicy() {
2105 +        final RejectedExecutionHandler handler = new CallerRunsPolicy();
2106 +        final ThreadPoolExecutor p =
2107 +            new ThreadPoolExecutor(1, 1,
2108 +                                   LONG_DELAY_MS, MILLISECONDS,
2109 +                                   new ArrayBlockingQueue<Runnable>(10));
2110 +        final AtomicReference<Thread> thread = new AtomicReference<>();
2111 +        final Runnable r = new Runnable() { public void run() {
2112 +            thread.set(Thread.currentThread()); }};
2113 +        handler.rejectedExecution(r, p);
2114 +        assertSame(Thread.currentThread(), thread.get());
2115 +        assertTrue(p.getRejectedExecutionHandler() instanceof AbortPolicy);
2116 +        assertEquals(0, p.getTaskCount());
2117 +        assertTrue(p.getQueue().isEmpty());
2118 +    }
2119 +
2120   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines