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

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.93 by jsr166, Mon May 29 19:15:03 2017 UTC vs.
Revision 1.94 by jsr166, Mon May 29 22:44:27 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.HashSet;
17   import java.util.List;
18   import java.util.concurrent.BlockingQueue;
# Line 257 | Line 259 | public class ScheduledExecutorTest exten
259              try {
260                  p.shutdown();
261                  p.schedule(new NoOpRunnable(),
262 <                           MEDIUM_DELAY_MS, MILLISECONDS);
262 >                           randomTimeout(), randomTimeUnit());
263                  shouldThrow();
264              } catch (RejectedExecutionException success) {
265              } catch (SecurityException ok) {}
# Line 273 | Line 275 | public class ScheduledExecutorTest exten
275              try {
276                  p.shutdown();
277                  p.schedule(new NoOpCallable(),
278 <                           MEDIUM_DELAY_MS, MILLISECONDS);
278 >                           randomTimeout(), randomTimeUnit());
279                  shouldThrow();
280              } catch (RejectedExecutionException success) {
281              } catch (SecurityException ok) {}
# Line 289 | Line 291 | public class ScheduledExecutorTest exten
291              try {
292                  p.shutdown();
293                  p.schedule(new NoOpCallable(),
294 <                           MEDIUM_DELAY_MS, MILLISECONDS);
294 >                           randomTimeout(), randomTimeUnit());
295                  shouldThrow();
296              } catch (RejectedExecutionException success) {
297              } catch (SecurityException ok) {}
# Line 964 | Line 966 | public class ScheduledExecutorTest exten
966      }
967  
968      /**
969 <     * invokeAny(null) throws NPE
969 >     * invokeAny(null) throws NullPointerException
970       */
971      public void testInvokeAny1() throws Exception {
972          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
# Line 977 | Line 979 | public class ScheduledExecutorTest exten
979      }
980  
981      /**
982 <     * invokeAny(empty collection) throws IAE
982 >     * invokeAny(empty collection) throws IllegalArgumentException
983       */
984      public void testInvokeAny2() throws Exception {
985          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
# Line 990 | Line 992 | public class ScheduledExecutorTest exten
992      }
993  
994      /**
995 <     * invokeAny(c) throws NPE if c has null elements
995 >     * invokeAny(c) throws NullPointerException if c has null elements
996       */
997      public void testInvokeAny3() throws Exception {
998          CountDownLatch latch = new CountDownLatch(1);
# Line 1052 | Line 1054 | public class ScheduledExecutorTest exten
1054      }
1055  
1056      /**
1057 <     * invokeAll(empty collection) returns empty collection
1057 >     * invokeAll(empty collection) returns empty list
1058       */
1059      public void testInvokeAll2() throws Exception {
1060          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1061 +        final Collection<Callable<String>> emptyCollection
1062 +            = Collections.emptyList();
1063          try (PoolCleaner cleaner = cleaner(e)) {
1064 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1064 >            List<Future<String>> r = e.invokeAll(emptyCollection);
1065              assertTrue(r.isEmpty());
1066          }
1067      }
# Line 1120 | Line 1124 | public class ScheduledExecutorTest exten
1124          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1125          try (PoolCleaner cleaner = cleaner(e)) {
1126              try {
1127 <                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1127 >                e.invokeAny(null, randomTimeout(), randomTimeUnit());
1128                  shouldThrow();
1129              } catch (NullPointerException success) {}
1130          }
1131      }
1132  
1133      /**
1134 <     * timed invokeAny(,,null) throws NPE
1134 >     * timed invokeAny(,,null) throws NullPointerException
1135       */
1136      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1137          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
# Line 1135 | Line 1139 | public class ScheduledExecutorTest exten
1139              List<Callable<String>> l = new ArrayList<>();
1140              l.add(new StringTask());
1141              try {
1142 <                e.invokeAny(l, MEDIUM_DELAY_MS, null);
1142 >                e.invokeAny(l, randomTimeout(), null);
1143                  shouldThrow();
1144              } catch (NullPointerException success) {}
1145          }
1146      }
1147  
1148      /**
1149 <     * timed invokeAny(empty collection) throws IAE
1149 >     * timed invokeAny(empty collection) throws IllegalArgumentException
1150       */
1151      public void testTimedInvokeAny2() throws Exception {
1152          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1153 +        final Collection<Callable<String>> emptyCollection
1154 +            = Collections.emptyList();
1155          try (PoolCleaner cleaner = cleaner(e)) {
1156              try {
1157 <                e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1157 >                e.invokeAny(emptyCollection, randomTimeout(), randomTimeUnit());
1158                  shouldThrow();
1159              } catch (IllegalArgumentException success) {}
1160          }
# Line 1165 | Line 1171 | public class ScheduledExecutorTest exten
1171              l.add(latchAwaitingStringTask(latch));
1172              l.add(null);
1173              try {
1174 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1174 >                e.invokeAny(l, randomTimeout(), randomTimeUnit());
1175                  shouldThrow();
1176              } catch (NullPointerException success) {}
1177              latch.countDown();
# Line 1214 | Line 1220 | public class ScheduledExecutorTest exten
1220          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1221          try (PoolCleaner cleaner = cleaner(e)) {
1222              try {
1223 <                e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1223 >                e.invokeAll(null, randomTimeout(), randomTimeUnit());
1224                  shouldThrow();
1225              } catch (NullPointerException success) {}
1226          }
# Line 1229 | Line 1235 | public class ScheduledExecutorTest exten
1235              List<Callable<String>> l = new ArrayList<>();
1236              l.add(new StringTask());
1237              try {
1238 <                e.invokeAll(l, MEDIUM_DELAY_MS, null);
1238 >                e.invokeAll(l, randomTimeout(), null);
1239                  shouldThrow();
1240              } catch (NullPointerException success) {}
1241          }
1242      }
1243  
1244      /**
1245 <     * timed invokeAll(empty collection) returns empty collection
1245 >     * timed invokeAll(empty collection) returns empty list
1246       */
1247      public void testTimedInvokeAll2() throws Exception {
1248          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1249 +        final Collection<Callable<String>> emptyCollection
1250 +            = Collections.emptyList();
1251          try (PoolCleaner cleaner = cleaner(e)) {
1252 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1253 <                                                 MEDIUM_DELAY_MS, MILLISECONDS);
1252 >            List<Future<String>> r =
1253 >                e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1254              assertTrue(r.isEmpty());
1255          }
1256      }
# Line 1257 | Line 1265 | public class ScheduledExecutorTest exten
1265              l.add(new StringTask());
1266              l.add(null);
1267              try {
1268 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1268 >                e.invokeAll(l, randomTimeout(), randomTimeUnit());
1269                  shouldThrow();
1270              } catch (NullPointerException success) {}
1271          }

Diff Legend

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