< prev index next >

test/jdk/java/util/concurrent/StructuredTaskScope/StructuredTaskScopeTest.java

Print this page

  44 import java.util.concurrent.Callable;
  45 import java.util.concurrent.ConcurrentHashMap;
  46 import java.util.concurrent.CountDownLatch;
  47 import java.util.concurrent.Executors;
  48 import java.util.concurrent.Future;
  49 import java.util.concurrent.LinkedTransferQueue;
  50 import java.util.concurrent.ThreadFactory;
  51 import java.util.concurrent.TimeUnit;
  52 import java.util.concurrent.RejectedExecutionException;
  53 import java.util.concurrent.ScheduledExecutorService;
  54 import java.util.concurrent.StructuredTaskScope;
  55 import java.util.concurrent.StructuredTaskScope.TimeoutException;
  56 import java.util.concurrent.StructuredTaskScope.Configuration;
  57 import java.util.concurrent.StructuredTaskScope.FailedException;
  58 import java.util.concurrent.StructuredTaskScope.Joiner;
  59 import java.util.concurrent.StructuredTaskScope.Subtask;
  60 import java.util.concurrent.StructureViolationException;
  61 import java.util.concurrent.atomic.AtomicBoolean;
  62 import java.util.concurrent.atomic.AtomicInteger;
  63 import java.util.concurrent.atomic.AtomicReference;
  64 import java.util.function.Function;
  65 import java.util.function.Predicate;

  66 import java.util.stream.Stream;
  67 import static java.lang.Thread.State.*;
  68 
  69 import org.junit.jupiter.api.Test;
  70 import org.junit.jupiter.api.BeforeAll;
  71 import org.junit.jupiter.api.AfterAll;
  72 import org.junit.jupiter.params.ParameterizedTest;
  73 import org.junit.jupiter.params.provider.MethodSource;
  74 import static org.junit.jupiter.api.Assertions.*;
  75 
  76 class StructuredTaskScopeTest {
  77     private static ScheduledExecutorService scheduler;
  78     private static List<ThreadFactory> threadFactories;
  79 
  80     @BeforeAll
  81     static void setup() throws Exception {
  82         scheduler = Executors.newSingleThreadScheduledExecutor();
  83 
  84         // thread factories
  85         String value = System.getProperty("threadFactory");

 192                 future.get();
 193             }
 194 
 195             // subtask cannot fork
 196             Subtask<Boolean> subtask = scope.fork(() -> {
 197                 assertThrows(WrongThreadException.class, () -> {
 198                     scope.fork(() -> null);
 199                 });
 200                 return true;
 201             });
 202             scope.join();
 203             assertTrue(subtask.get());
 204         }
 205     }
 206 
 207     /**
 208      * Test fork after join, no subtasks forked before join.
 209      */
 210     @ParameterizedTest
 211     @MethodSource("factories")
 212     void testForkAfterJoin1(ThreadFactory factory) throws Exception {
 213         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 214                 cf -> cf.withThreadFactory(factory))) {
 215             scope.join();
 216             assertThrows(IllegalStateException.class, () -> scope.fork(() -> "bar"));
 217         }
 218     }
 219 
 220     /**
 221      * Test fork after join, subtasks forked before join.
 222      */
 223     @ParameterizedTest
 224     @MethodSource("factories")
 225     void testForkAfterJoin2(ThreadFactory factory) throws Exception {
 226         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 227                 cf -> cf.withThreadFactory(factory))) {
 228             scope.fork(() -> "foo");
 229             scope.join();
 230             assertThrows(IllegalStateException.class, () -> scope.fork(() -> "bar"));
 231         }
 232     }
 233 
 234     /**
 235      * Test fork after join throws.
 236      */
 237     @ParameterizedTest
 238     @MethodSource("factories")
 239     void testForkAfterJoinThrows(ThreadFactory factory) throws Exception {
 240         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 241                 cf -> cf.withThreadFactory(factory))) {
 242             var latch = new CountDownLatch(1);
 243             var subtask1 = scope.fork(() -> {
 244                 latch.await();
 245                 return "foo";
 246             });
 247 
 248             // join throws
 249             Thread.currentThread().interrupt();
 250             assertThrows(InterruptedException.class, scope::join);
 251 
 252             // fork should throw
 253             assertThrows(IllegalStateException.class, () -> scope.fork(() -> "bar"));
 254         }
 255     }
 256 



















 257     /**
 258      * Test fork after task scope is cancelled. This test uses a custom Joiner to
 259      * cancel execution.
 260      */
 261     @ParameterizedTest
 262     @MethodSource("factories")
 263     void testForkAfterCancel2(ThreadFactory factory) throws Exception {
 264         var countingThreadFactory = new CountingThreadFactory(factory);
 265         var testJoiner = new CancelAfterOneJoiner<String>();
 266 
 267         try (var scope = StructuredTaskScope.open(testJoiner,
 268                 cf -> cf.withThreadFactory(countingThreadFactory))) {
 269 
 270             // fork subtask, the scope should be cancelled when the subtask completes
 271             var subtask1 = scope.fork(() -> "foo");
 272             awaitCancelled(scope);
 273 
 274             assertEquals(1, countingThreadFactory.threadCount());
 275             assertEquals(1, testJoiner.onForkCount());
 276             assertEquals(1, testJoiner.onCompleteCount());

 279             var subtask2 = scope.fork(() -> "bar");
 280 
 281             // onFork should be invoked, newThread and onComplete should not be invoked
 282             assertEquals(1, countingThreadFactory.threadCount());
 283             assertEquals(2, testJoiner.onForkCount());
 284             assertEquals(1, testJoiner.onCompleteCount());
 285 
 286             scope.join();
 287 
 288             assertEquals(1, countingThreadFactory.threadCount());
 289             assertEquals(2, testJoiner.onForkCount());
 290             assertEquals(1, testJoiner.onCompleteCount());
 291             assertEquals("foo", subtask1.get());
 292             assertEquals(Subtask.State.UNAVAILABLE, subtask2.state());
 293         }
 294     }
 295 
 296     /**
 297      * Test fork after task scope is closed.
 298      */
 299     @Test
 300     void testForkAfterClose() {
 301         try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {


 302             scope.close();
 303             assertThrows(IllegalStateException.class, () -> scope.fork(() -> null));
 304         }
 305     }
 306 
 307     /**
 308      * Test fork with a ThreadFactory that rejects creating a thread.
 309      */
 310     @Test
 311     void testForkRejectedExecutionException() {
 312         ThreadFactory factory = task -> null;
 313         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 314                 cf -> cf.withThreadFactory(factory))) {
 315             assertThrows(RejectedExecutionException.class, () -> scope.fork(() -> null));
 316         }
 317     }
 318 
 319     /**
 320      * Test join with no subtasks.
 321      */

 365      * Test join after join completed with an exception.
 366      */
 367     @Test
 368     void testJoinAfterJoin2() throws Exception {
 369         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow())) {
 370             scope.fork(() -> { throw new FooException(); });
 371             Throwable ex = assertThrows(FailedException.class, scope::join);
 372             assertTrue(ex.getCause() instanceof FooException);
 373 
 374             // join already called
 375             for (int i = 0 ; i < 3; i++) {
 376                 assertThrows(IllegalStateException.class, scope::join);
 377             }
 378         }
 379     }
 380 
 381     /**
 382      * Test join after join completed with a timeout.
 383      */
 384     @Test
 385     void testJoinAfterJoin3() throws Exception {



























 386         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow(),
 387                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
 388             // wait for scope to be cancelled by timeout
 389             awaitCancelled(scope);
 390             assertThrows(TimeoutException.class, scope::join);
 391 
 392             // join already called
 393             for (int i = 0 ; i < 3; i++) {
 394                 assertThrows(IllegalStateException.class, scope::join);
 395             }
 396         }
 397     }
 398 





























 399     /**
 400      * Test join method is owner confined.
 401      */
 402     @ParameterizedTest
 403     @MethodSource("factories")
 404     void testJoinConfined(ThreadFactory factory) throws Exception {
 405         try (var scope = StructuredTaskScope.open(Joiner.<Boolean>awaitAll(),
 406                 cf -> cf.withThreadFactory(factory))) {
 407 
 408             // random thread cannot join
 409             try (var pool = Executors.newSingleThreadExecutor()) {
 410                 Future<Void> future = pool.submit(() -> {
 411                     assertThrows(WrongThreadException.class, scope::join);
 412                     return null;
 413                 });
 414                 future.get();
 415             }
 416 
 417             // subtask cannot join
 418             Subtask<Boolean> subtask = scope.fork(() -> {
 419                 assertThrows(WrongThreadException.class, () -> { scope.join(); });
 420                 return true;
 421             });
 422             scope.join();
 423             assertTrue(subtask.get());
 424         }
 425     }
 426 
 427     /**
 428      * Test join with interrupt status set.
 429      */
 430     @ParameterizedTest
 431     @MethodSource("factories")
 432     void testInterruptJoin1(ThreadFactory factory) throws Exception {
 433         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 434                 cf -> cf.withThreadFactory(factory))) {
 435 
 436             Subtask<String> subtask = scope.fork(() -> {
 437                 Thread.sleep(60_000);
 438                 return "foo";
 439             });
 440 
 441             // join should throw
 442             Thread.currentThread().interrupt();
 443             try {
 444                 scope.join();
 445                 fail("join did not throw");
 446             } catch (InterruptedException expected) {
 447                 assertFalse(Thread.interrupted());   // interrupt status should be cleared
 448             }
 449         }
 450     }
 451 
 452     /**
 453      * Test interrupt of thread blocked in join.
 454      */
 455     @ParameterizedTest
 456     @MethodSource("factories")
 457     void testInterruptJoin2(ThreadFactory factory) throws Exception {
 458         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 459                 cf -> cf.withThreadFactory(factory))) {
 460 
 461             var latch = new CountDownLatch(1);
 462             Subtask<String> subtask = scope.fork(() -> {
 463                 Thread.sleep(60_000);
 464                 return "foo";
 465             });
 466 
 467             // interrupt main thread when it blocks in join
 468             scheduleInterruptAt("java.util.concurrent.StructuredTaskScopeImpl.join");
 469             try {
 470                 scope.join();
 471                 fail("join did not throw");
 472             } catch (InterruptedException expected) {
 473                 assertFalse(Thread.interrupted());   // interrupt status should be clear
 474             }
 475         }
 476     }
 477 
 478     /**
 479      * Test join when scope is cancelled.
 480      */
 481     @ParameterizedTest
 482     @MethodSource("factories")
 483     void testJoinWhenCancelled(ThreadFactory factory) throws Exception {

 948     @Test
 949     void testOnCompleteCancelsExecution() throws Exception {
 950         var joiner = new Joiner<String, Void>() {
 951             @Override
 952             public boolean onComplete(Subtask<? extends String> subtask) {
 953                 return true;
 954             }
 955             @Override
 956             public Void result() {
 957                 return null;
 958             }
 959         };
 960         try (var scope = StructuredTaskScope.open(joiner)) {
 961             assertFalse(scope.isCancelled());
 962             scope.fork(() -> "foo");
 963             awaitCancelled(scope);
 964             scope.join();
 965         }
 966     }
 967 




























































 968     /**
 969      * Test toString.
 970      */
 971     @Test
 972     void testToString() throws Exception {
 973         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 974                 cf -> cf.withName("duke"))) {
 975 
 976             // open
 977             assertTrue(scope.toString().contains("duke"));
 978 
 979             // closed
 980             scope.close();
 981             assertTrue(scope.toString().contains("duke"));
 982         }
 983     }
 984 
 985     /**
 986      * Test Subtask with task that completes successfully.
 987      */
 988     @ParameterizedTest
 989     @MethodSource("factories")
 990     void testSubtaskWhenSuccess(ThreadFactory factory) throws Exception {
 991         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
 992                 cf -> cf.withThreadFactory(factory))) {
 993 
 994             Subtask<String> subtask = scope.fork(() -> "foo");
 995 
 996             // before join
 997             assertThrows(IllegalStateException.class, subtask::get);
 998             assertThrows(IllegalStateException.class, subtask::exception);
 999 




1000             scope.join();
1001 
1002             // after join
1003             assertEquals(Subtask.State.SUCCESS, subtask.state());


1004             assertEquals("foo", subtask.get());
1005             assertThrows(IllegalStateException.class, subtask::exception);




1006         }
1007     }
1008 
1009     /**
1010      * Test Subtask with task that fails.
1011      */
1012     @ParameterizedTest
1013     @MethodSource("factories")
1014     void testSubtaskWhenFailed(ThreadFactory factory) throws Exception {
1015         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1016                 cf -> cf.withThreadFactory(factory))) {
1017 
1018             Subtask<String> subtask = scope.fork(() -> { throw new FooException(); });
1019 
1020             // before join
1021             assertThrows(IllegalStateException.class, subtask::get);
1022             assertThrows(IllegalStateException.class, subtask::exception);
1023 




1024             scope.join();
1025 
1026             // after join
1027             assertEquals(Subtask.State.FAILED, subtask.state());


1028             assertThrows(IllegalStateException.class, subtask::get);
1029             assertTrue(subtask.exception() instanceof FooException);




1030         }
1031     }
1032 
1033     /**
1034      * Test Subtask with a task that has not completed.
1035      */
1036     @ParameterizedTest
1037     @MethodSource("factories")
1038     void testSubtaskWhenNotCompleted(ThreadFactory factory) throws Exception {
1039         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
1040                 cf -> cf.withThreadFactory(factory))) {
1041             Subtask<Void> subtask = scope.fork(() -> {
1042                 Thread.sleep(Duration.ofDays(1));
1043                 return null;
1044             });
1045 
1046             // before join
1047             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());


1048             assertThrows(IllegalStateException.class, subtask::get);
1049             assertThrows(IllegalStateException.class, subtask::exception);
1050 




1051             // attempt join, join throws
1052             Thread.currentThread().interrupt();
1053             assertThrows(InterruptedException.class, scope::join);
1054 
1055             // after join
1056             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());


1057             assertThrows(IllegalStateException.class, subtask::get);
1058             assertThrows(IllegalStateException.class, subtask::exception);




1059         }
1060     }
1061 
1062     /**
1063      * Test Subtask forked after execution cancelled.
1064      */
1065     @ParameterizedTest
1066     @MethodSource("factories")
1067     void testSubtaskWhenCancelled(ThreadFactory factory) throws Exception {
1068         try (var scope = StructuredTaskScope.open(new CancelAfterOneJoiner<String>())) {
1069             scope.fork(() -> "foo");
1070             awaitCancelled(scope);
1071 
1072             var subtask = scope.fork(() -> "foo");
1073 
1074             // before join
1075             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());
1076             assertThrows(IllegalStateException.class, subtask::get);
1077             assertThrows(IllegalStateException.class, subtask::exception);
1078 




1079             scope.join();
1080 
1081             // after join
1082             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());


1083             assertThrows(IllegalStateException.class, subtask::get);
1084             assertThrows(IllegalStateException.class, subtask::exception);




1085         }
1086     }
1087 
1088     /**
1089      * Test Subtask::toString.
1090      */
1091     @Test
1092     void testSubtaskToString() throws Exception {
1093         try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
1094             var latch = new CountDownLatch(1);
1095             var subtask1 = scope.fork(() -> {
1096                 latch.await();
1097                 return "foo";
1098             });
1099             var subtask2 = scope.fork(() -> { throw new FooException(); });
1100 
1101             // subtask1 result is unavailable
1102             assertTrue(subtask1.toString().contains("Unavailable"));
1103             latch.countDown();
1104 

1139 
1140     /**
1141      * Test Joiner.allSuccessfulOrThrow() with a subtask that complete successfully and
1142      * a subtask that fails.
1143      */
1144     @ParameterizedTest
1145     @MethodSource("factories")
1146     void testAllSuccessfulOrThrow3(ThreadFactory factory) throws Throwable {
1147         try (var scope = StructuredTaskScope.open(Joiner.<String>allSuccessfulOrThrow(),
1148                 cf -> cf.withThreadFactory(factory))) {
1149             scope.fork(() -> "foo");
1150             scope.fork(() -> { throw new FooException(); });
1151             try {
1152                 scope.join();
1153             } catch (FailedException e) {
1154                 assertTrue(e.getCause() instanceof FooException);
1155             }
1156         }
1157     }
1158 



















1159     /**
1160      * Test Joiner.anySuccessfulResultOrThrow() with no subtasks.
1161      */
1162     @Test
1163     void testAnySuccessfulResultOrThrow1() throws Exception {
1164         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow())) {
1165             try {
1166                 scope.join();
1167             } catch (FailedException e) {
1168                 assertTrue(e.getCause() instanceof NoSuchElementException);
1169             }
1170         }
1171     }
1172 
1173     /**
1174      * Test Joiner.anySuccessfulResultOrThrow() with a subtask that completes successfully.
1175      */
1176     @ParameterizedTest
1177     @MethodSource("factories")
1178     void testAnySuccessfulResultOrThrow2(ThreadFactory factory) throws Exception {

1212             scope.fork(() -> { throw new FooException(); });
1213             String first = scope.join();
1214             assertEquals("foo", first);
1215         }
1216     }
1217 
1218     /**
1219      * Test Joiner.anySuccessfulResultOrThrow() with a subtask that fails.
1220      */
1221     @ParameterizedTest
1222     @MethodSource("factories")
1223     void testAnySuccessfulResultOrThrow5(ThreadFactory factory) throws Exception {
1224         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow(),
1225                 cf -> cf.withThreadFactory(factory))) {
1226             scope.fork(() -> { throw new FooException(); });
1227             Throwable ex = assertThrows(FailedException.class, scope::join);
1228             assertTrue(ex.getCause() instanceof FooException);
1229         }
1230     }
1231 



















1232     /**
1233      * Test Joiner.awaitAllSuccessfulOrThrow() with no subtasks.
1234      */
1235     @Test
1236     void testAwaitSuccessfulOrThrow1() throws Throwable {
1237         try (var scope = StructuredTaskScope.open(Joiner.awaitAllSuccessfulOrThrow())) {
1238             var result = scope.join();
1239             assertNull(result);
1240         }
1241     }
1242 
1243     /**
1244      * Test Joiner.awaitAllSuccessfulOrThrow() with subtasks that complete successfully.
1245      */
1246     @ParameterizedTest
1247     @MethodSource("factories")
1248     void testAwaitSuccessfulOrThrow2(ThreadFactory factory) throws Throwable {
1249         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAllSuccessfulOrThrow(),
1250                 cf -> cf.withThreadFactory(factory))) {
1251             var subtask1 = scope.fork(() -> "foo");

1259 
1260     /**
1261      * Test Joiner.awaitAllSuccessfulOrThrow() with a subtask that complete successfully and
1262      * a subtask that fails.
1263      */
1264     @ParameterizedTest
1265     @MethodSource("factories")
1266     void testAwaitSuccessfulOrThrow3(ThreadFactory factory) throws Throwable {
1267         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAllSuccessfulOrThrow(),
1268                 cf -> cf.withThreadFactory(factory))) {
1269             scope.fork(() -> "foo");
1270             scope.fork(() -> { throw new FooException(); });
1271             try {
1272                 scope.join();
1273             } catch (FailedException e) {
1274                 assertTrue(e.getCause() instanceof FooException);
1275             }
1276         }
1277     }
1278 



















1279     /**
1280      * Test Joiner.awaitAll() with no subtasks.
1281      */
1282     @Test
1283     void testAwaitAll1() throws Throwable {
1284         try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
1285             var result = scope.join();
1286             assertNull(result);
1287         }
1288     }
1289 
1290     /**
1291      * Test Joiner.awaitAll() with subtasks that complete successfully.
1292      */
1293     @ParameterizedTest
1294     @MethodSource("factories")
1295     void testAwaitAll2(ThreadFactory factory) throws Throwable {
1296         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1297                 cf -> cf.withThreadFactory(factory))) {
1298             var subtask1 = scope.fork(() -> "foo");

1305     }
1306 
1307     /**
1308      * Test Joiner.awaitAll() with a subtask that complete successfully and a subtask
1309      * that fails.
1310      */
1311     @ParameterizedTest
1312     @MethodSource("factories")
1313     void testAwaitAll3(ThreadFactory factory) throws Throwable {
1314         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1315                 cf -> cf.withThreadFactory(factory))) {
1316             var subtask1 = scope.fork(() -> "foo");
1317             var subtask2 = scope.fork(() -> { throw new FooException(); });
1318             var result = scope.join();
1319             assertNull(result);
1320             assertEquals("foo", subtask1.get());
1321             assertTrue(subtask2.exception() instanceof FooException);
1322         }
1323     }
1324 



















1325     /**
1326      * Test Joiner.allUntil(Predicate) with no subtasks.
1327      */
1328     @Test
1329     void testAllUntil1() throws Throwable {
1330         try (var scope = StructuredTaskScope.open(Joiner.allUntil(s -> false))) {
1331             var subtasks = scope.join();
1332             assertEquals(0, subtasks.count());
1333         }
1334     }
1335 
1336     /**
1337      * Test Joiner.allUntil(Predicate) with no cancellation.
1338      */
1339     @ParameterizedTest
1340     @MethodSource("factories")
1341     void testAllUntil2(ThreadFactory factory) throws Exception {
1342         try (var scope = StructuredTaskScope.open(Joiner.<String>allUntil(s -> false),
1343                 cf -> cf.withThreadFactory(factory))) {
1344 
1345             var subtask1 = scope.fork(() -> "foo");
1346             var subtask2 = scope.fork(() -> { throw new FooException(); });
1347 
1348             var subtasks = scope.join().toList();
1349             assertEquals(2, subtasks.size());
1350 
1351             assertSame(subtask1, subtasks.get(0));
1352             assertSame(subtask2, subtasks.get(1));
1353             assertEquals("foo", subtask1.get());
1354             assertTrue(subtask2.exception() instanceof FooException);
1355         }
1356     }
1357 
1358     /**
1359      * Test Joiner.allUntil(Predicate) with cancellation after one subtask completes.
1360      */
1361     @ParameterizedTest
1362     @MethodSource("factories")
1363     void testAllUntil3(ThreadFactory factory) throws Exception {
1364         try (var scope = StructuredTaskScope.open(Joiner.<String>allUntil(s -> true),
1365                 cf -> cf.withThreadFactory(factory))) {
1366 
1367             var subtask1 = scope.fork(() -> "foo");
1368             var subtask2 = scope.fork(() -> {
1369                 Thread.sleep(Duration.ofDays(1));
1370                 return "bar";
1371             });
1372 
1373             var subtasks = scope.join().toList();

1374 
1375             assertEquals(2, subtasks.size());
1376             assertSame(subtask1, subtasks.get(0));
1377             assertSame(subtask2, subtasks.get(1));
1378             assertEquals("foo", subtask1.get());
1379             assertEquals(Subtask.State.UNAVAILABLE, subtask2.state());
1380         }
1381     }
1382 
1383     /**
1384      * Test Joiner.allUntil(Predicate) with cancellation after serveral subtasks complete.
1385      */
1386     @ParameterizedTest
1387     @MethodSource("factories")
1388     void testAllUntil4(ThreadFactory factory) throws Exception {
1389 
1390         // cancel execution after two or more failures
1391         class CancelAfterTwoFailures<T> implements Predicate<Subtask<? extends T>> {
1392             final AtomicInteger failedCount = new AtomicInteger();
1393             @Override
1394             public boolean test(Subtask<? extends T> subtask) {
1395                 return subtask.state() == Subtask.State.FAILED
1396                         && failedCount.incrementAndGet() >= 2;
1397             }

1420     }
1421 
1422     /**
1423      * Test Test Joiner.allUntil(Predicate) where the Predicate's test method throws.
1424      */
1425     @Test
1426     void testAllUntil5() throws Exception {
1427         var joiner = Joiner.allUntil(_ -> { throw new FooException(); });
1428         var excRef = new AtomicReference<Throwable>();
1429         Thread.UncaughtExceptionHandler uhe = (t, e) -> excRef.set(e);
1430         ThreadFactory factory = Thread.ofVirtual()
1431                 .uncaughtExceptionHandler(uhe)
1432                 .factory();
1433         try (var scope = StructuredTaskScope.open(joiner, cf -> cf.withThreadFactory(factory))) {
1434             scope.fork(() -> "foo");
1435             scope.join();
1436             assertInstanceOf(FooException.class, excRef.get());
1437         }
1438     }
1439 

























1440     /**
1441      * Test Joiner default methods.
1442      */
1443     @Test
1444     void testJoinerDefaultMethods() throws Exception {
1445         try (var scope = StructuredTaskScope.open(new CancelAfterOneJoiner<String>())) {
1446 
1447             // need subtasks to test default methods
1448             var subtask1 = scope.fork(() -> "foo");
1449             awaitCancelled(scope);
1450             var subtask2 = scope.fork(() -> "bar");
1451             scope.join();
1452 
1453             assertEquals(Subtask.State.SUCCESS, subtask1.state());
1454             assertEquals(Subtask.State.UNAVAILABLE, subtask2.state());
1455 
1456             // Joiner that does not override default methods
1457             Joiner<Object, Void> joiner = () -> null;
1458             assertThrows(NullPointerException.class, () -> joiner.onFork(null));
1459             assertThrows(NullPointerException.class, () -> joiner.onComplete(null));
1460             assertThrows(IllegalArgumentException.class, () -> joiner.onFork(subtask1));
1461             assertFalse(joiner.onFork(subtask2));
1462             assertFalse(joiner.onComplete(subtask1));
1463             assertThrows(IllegalArgumentException.class, () -> joiner.onComplete(subtask2));

1464         }
1465     }
1466 
1467     /**
1468      * Test Joiners onFork/onComplete methods with a subtask in an unexpected state.
1469      */
1470     @Test
1471     void testJoinersWithUnavailableResult() throws Exception {
1472         try (var scope = StructuredTaskScope.open()) {
1473             var done = new CountDownLatch(1);
1474             var subtask = scope.fork(() -> {
1475                 done.await();
1476                 return null;
1477             });
1478 
1479             // onComplete with uncompleted task should throw IAE
1480             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());
1481             assertThrows(IllegalArgumentException.class,
1482                     () -> Joiner.allSuccessfulOrThrow().onComplete(subtask));
1483             assertThrows(IllegalArgumentException.class,

1506                     () -> Joiner.allUntil(_ -> false).onFork(subtask));
1507         }
1508 
1509     }
1510 
1511     /**
1512      * Test the Configuration function apply method throwing an exception.
1513      */
1514     @Test
1515     void testConfigFunctionThrows() throws Exception {
1516         assertThrows(FooException.class,
1517                 () -> StructuredTaskScope.open(Joiner.awaitAll(),
1518                                                cf -> { throw new FooException(); }));
1519     }
1520 
1521     /**
1522      * Test Configuration equals/hashCode/toString
1523      */
1524     @Test
1525     void testConfigMethods() throws Exception {
1526         Function<Configuration, Configuration> testConfig = cf -> {
1527             var name = "duke";
1528             var threadFactory = Thread.ofPlatform().factory();
1529             var timeout = Duration.ofSeconds(10);
1530 
1531             assertEquals(cf, cf);
1532             assertEquals(cf.withName(name), cf.withName(name));
1533             assertEquals(cf.withThreadFactory(threadFactory), cf.withThreadFactory(threadFactory));
1534             assertEquals(cf.withTimeout(timeout), cf.withTimeout(timeout));
1535 
1536             assertNotEquals(cf, cf.withName(name));
1537             assertNotEquals(cf, cf.withThreadFactory(threadFactory));
1538             assertNotEquals(cf, cf.withTimeout(timeout));
1539 
1540             assertEquals(cf.withName(name).hashCode(), cf.withName(name).hashCode());
1541             assertEquals(cf.withThreadFactory(threadFactory).hashCode(),
1542                     cf.withThreadFactory(threadFactory).hashCode());
1543             assertEquals(cf.withTimeout(timeout).hashCode(), cf.withTimeout(timeout).hashCode());
1544 
1545             assertTrue(cf.withName(name).toString().contains(name));
1546             assertTrue(cf.withThreadFactory(threadFactory).toString().contains(threadFactory.toString()));
1547             assertTrue(cf.withTimeout(timeout).toString().contains(timeout.toString()));
1548 
1549             return cf;
1550         };
1551         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(), testConfig)) {
1552             // do nothing
1553         }
1554     }
1555 
1556     /**
1557      * Test for NullPointerException.
1558      */
1559     @Test
1560     void testNulls() throws Exception {
1561         assertThrows(NullPointerException.class,
1562                 () -> StructuredTaskScope.open(null));
1563         assertThrows(NullPointerException.class,
1564                 () -> StructuredTaskScope.open(null, cf -> cf));
1565         assertThrows(NullPointerException.class,
1566                 () -> StructuredTaskScope.open(Joiner.awaitAll(), null));
1567 
1568         assertThrows(NullPointerException.class, () -> Joiner.allUntil(null));
1569 
1570         // fork
1571         try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {

1738                 found = true;
1739             } else {
1740                 Thread.sleep(20);
1741             }
1742         }
1743         target.interrupt();
1744     }
1745 
1746     /**
1747      * Schedules the current thread to be interrupted when it waits (timed or untimed)
1748      * at the given location.
1749      */
1750     private void scheduleInterruptAt(String location) {
1751         Thread target = Thread.currentThread();
1752         scheduler.submit(() -> {
1753             interruptThreadAt(target, location);
1754             return null;
1755         });
1756     }
1757 


































1758     /**
1759      * Returns true if the given stack trace contains an element for the given class
1760      * and method name.
1761      */
1762     private boolean contains(StackTraceElement[] stack, String className, String methodName) {
1763         return Arrays.stream(stack)
1764                 .anyMatch(e -> className.equals(e.getClassName())
1765                         && methodName.equals(e.getMethodName()));
1766     }
1767 }

  44 import java.util.concurrent.Callable;
  45 import java.util.concurrent.ConcurrentHashMap;
  46 import java.util.concurrent.CountDownLatch;
  47 import java.util.concurrent.Executors;
  48 import java.util.concurrent.Future;
  49 import java.util.concurrent.LinkedTransferQueue;
  50 import java.util.concurrent.ThreadFactory;
  51 import java.util.concurrent.TimeUnit;
  52 import java.util.concurrent.RejectedExecutionException;
  53 import java.util.concurrent.ScheduledExecutorService;
  54 import java.util.concurrent.StructuredTaskScope;
  55 import java.util.concurrent.StructuredTaskScope.TimeoutException;
  56 import java.util.concurrent.StructuredTaskScope.Configuration;
  57 import java.util.concurrent.StructuredTaskScope.FailedException;
  58 import java.util.concurrent.StructuredTaskScope.Joiner;
  59 import java.util.concurrent.StructuredTaskScope.Subtask;
  60 import java.util.concurrent.StructureViolationException;
  61 import java.util.concurrent.atomic.AtomicBoolean;
  62 import java.util.concurrent.atomic.AtomicInteger;
  63 import java.util.concurrent.atomic.AtomicReference;

  64 import java.util.function.Predicate;
  65 import java.util.function.UnaryOperator;
  66 import java.util.stream.Stream;
  67 import static java.lang.Thread.State.*;
  68 
  69 import org.junit.jupiter.api.Test;
  70 import org.junit.jupiter.api.BeforeAll;
  71 import org.junit.jupiter.api.AfterAll;
  72 import org.junit.jupiter.params.ParameterizedTest;
  73 import org.junit.jupiter.params.provider.MethodSource;
  74 import static org.junit.jupiter.api.Assertions.*;
  75 
  76 class StructuredTaskScopeTest {
  77     private static ScheduledExecutorService scheduler;
  78     private static List<ThreadFactory> threadFactories;
  79 
  80     @BeforeAll
  81     static void setup() throws Exception {
  82         scheduler = Executors.newSingleThreadScheduledExecutor();
  83 
  84         // thread factories
  85         String value = System.getProperty("threadFactory");

 192                 future.get();
 193             }
 194 
 195             // subtask cannot fork
 196             Subtask<Boolean> subtask = scope.fork(() -> {
 197                 assertThrows(WrongThreadException.class, () -> {
 198                     scope.fork(() -> null);
 199                 });
 200                 return true;
 201             });
 202             scope.join();
 203             assertTrue(subtask.get());
 204         }
 205     }
 206 
 207     /**
 208      * Test fork after join, no subtasks forked before join.
 209      */
 210     @ParameterizedTest
 211     @MethodSource("factories")
 212     void testForkAfterJoinCompleted1(ThreadFactory factory) throws Exception {
 213         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 214                 cf -> cf.withThreadFactory(factory))) {
 215             scope.join();
 216             assertThrows(IllegalStateException.class, () -> scope.fork(() -> "bar"));
 217         }
 218     }
 219 
 220     /**
 221      * Test fork after join, subtasks forked before join.
 222      */
 223     @ParameterizedTest
 224     @MethodSource("factories")
 225     void testForkAfterJoinCompleted2(ThreadFactory factory) throws Exception {
 226         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 227                 cf -> cf.withThreadFactory(factory))) {
 228             scope.fork(() -> "foo");
 229             scope.join();
 230             assertThrows(IllegalStateException.class, () -> scope.fork(() -> "bar"));
 231         }
 232     }
 233 
 234     /**
 235      * Test fork after join interrupted.
 236      */
 237     @ParameterizedTest
 238     @MethodSource("factories")
 239     void testForkAfterJoinInterrupted(ThreadFactory factory) throws Exception {
 240         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 241                 cf -> cf.withThreadFactory(factory))) {

 242             var subtask1 = scope.fork(() -> {
 243                 Thread.sleep(Duration.ofDays(1));
 244                 return "foo";
 245             });
 246 
 247             // join throws
 248             Thread.currentThread().interrupt();
 249             assertThrows(InterruptedException.class, scope::join);
 250 
 251             // fork should throw
 252             assertThrows(IllegalStateException.class, () -> scope.fork(() -> "bar"));
 253         }
 254     }
 255 
 256     /**
 257      * Test fork after join timeout.
 258      */
 259     @ParameterizedTest
 260     @MethodSource("factories")
 261     void testForkAfterJoinTimeout(ThreadFactory factory) throws Exception {
 262         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 263                 cf -> cf.withThreadFactory(factory)
 264                         .withTimeout(Duration.ofMillis(100)))) {
 265             awaitCancelled(scope);
 266 
 267             // join throws
 268             assertThrows(TimeoutException.class, scope::join);
 269 
 270             // fork should throw
 271             assertThrows(IllegalStateException.class, () -> scope.fork(() -> "bar"));
 272         }
 273     }
 274 
 275     /**
 276      * Test fork after task scope is cancelled. This test uses a custom Joiner to
 277      * cancel execution.
 278      */
 279     @ParameterizedTest
 280     @MethodSource("factories")
 281     void testForkAfterCancel2(ThreadFactory factory) throws Exception {
 282         var countingThreadFactory = new CountingThreadFactory(factory);
 283         var testJoiner = new CancelAfterOneJoiner<String>();
 284 
 285         try (var scope = StructuredTaskScope.open(testJoiner,
 286                 cf -> cf.withThreadFactory(countingThreadFactory))) {
 287 
 288             // fork subtask, the scope should be cancelled when the subtask completes
 289             var subtask1 = scope.fork(() -> "foo");
 290             awaitCancelled(scope);
 291 
 292             assertEquals(1, countingThreadFactory.threadCount());
 293             assertEquals(1, testJoiner.onForkCount());
 294             assertEquals(1, testJoiner.onCompleteCount());

 297             var subtask2 = scope.fork(() -> "bar");
 298 
 299             // onFork should be invoked, newThread and onComplete should not be invoked
 300             assertEquals(1, countingThreadFactory.threadCount());
 301             assertEquals(2, testJoiner.onForkCount());
 302             assertEquals(1, testJoiner.onCompleteCount());
 303 
 304             scope.join();
 305 
 306             assertEquals(1, countingThreadFactory.threadCount());
 307             assertEquals(2, testJoiner.onForkCount());
 308             assertEquals(1, testJoiner.onCompleteCount());
 309             assertEquals("foo", subtask1.get());
 310             assertEquals(Subtask.State.UNAVAILABLE, subtask2.state());
 311         }
 312     }
 313 
 314     /**
 315      * Test fork after task scope is closed.
 316      */
 317     @ParameterizedTest
 318     @MethodSource("factories")
 319     void testForkAfterClose(ThreadFactory factory) {
 320         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 321                 cf -> cf.withThreadFactory(factory))) {
 322             scope.close();
 323             assertThrows(IllegalStateException.class, () -> scope.fork(() -> null));
 324         }
 325     }
 326 
 327     /**
 328      * Test fork with a ThreadFactory that rejects creating a thread.
 329      */
 330     @Test
 331     void testForkRejectedExecutionException() {
 332         ThreadFactory factory = task -> null;
 333         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 334                 cf -> cf.withThreadFactory(factory))) {
 335             assertThrows(RejectedExecutionException.class, () -> scope.fork(() -> null));
 336         }
 337     }
 338 
 339     /**
 340      * Test join with no subtasks.
 341      */

 385      * Test join after join completed with an exception.
 386      */
 387     @Test
 388     void testJoinAfterJoin2() throws Exception {
 389         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow())) {
 390             scope.fork(() -> { throw new FooException(); });
 391             Throwable ex = assertThrows(FailedException.class, scope::join);
 392             assertTrue(ex.getCause() instanceof FooException);
 393 
 394             // join already called
 395             for (int i = 0 ; i < 3; i++) {
 396                 assertThrows(IllegalStateException.class, scope::join);
 397             }
 398         }
 399     }
 400 
 401     /**
 402      * Test join after join completed with a timeout.
 403      */
 404     @Test
 405     void testJoinAfterJoinInterrupted() throws Exception {
 406         try (var scope = StructuredTaskScope.open()) {
 407             var latch = new CountDownLatch(1);
 408             var subtask = scope.fork(() -> {
 409                 latch.await();
 410                 return "foo";
 411             });
 412 
 413             // join throws InterruptedException
 414             Thread.currentThread().interrupt();
 415             assertThrows(InterruptedException.class, scope::join);
 416 
 417             latch.countDown();
 418 
 419             // retry join to get result
 420             scope.join();
 421             assertEquals("foo", subtask.get());
 422 
 423             // retry after otbaining result
 424             assertThrows(IllegalStateException.class, scope::join);
 425         }
 426     }
 427 
 428     /**
 429      * Test join after join completed with a timeout.
 430      */
 431     @Test
 432     void testJoinAfterJoinTimeout() throws Exception {
 433         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow(),
 434                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
 435             // wait for scope to be cancelled by timeout
 436             awaitCancelled(scope);
 437             assertThrows(TimeoutException.class, scope::join);
 438 
 439             // join already called
 440             for (int i = 0 ; i < 3; i++) {
 441                 assertThrows(IllegalStateException.class, scope::join);
 442             }
 443         }
 444     }
 445 
 446     /**
 447      * Test join invoked from Joiner.onTimeout.
 448      */
 449     @Test
 450     void testJoinInOnTimeout() throws Exception {
 451         Thread owner = Thread.currentThread();
 452         var scopeRef = new AtomicReference<StructuredTaskScope<?, ?>>();
 453 
 454         var joiner = new Joiner<String, Void>() {
 455             @Override
 456             public void onTimeout() {
 457                 assertTrue(Thread.currentThread() == owner);
 458                 var scope = scopeRef.get();
 459                 assertThrows(IllegalStateException.class, scope::join);
 460             }
 461             @Override
 462             public Void result() {
 463                 return null;
 464             }
 465         };
 466 
 467         try (var scope = StructuredTaskScope.open(joiner,
 468                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
 469             awaitCancelled(scope);
 470             scopeRef.set(scope);
 471             scope.join();  // invokes onTimeout
 472         }
 473     }
 474 
 475     /**
 476      * Test join method is owner confined.
 477      */
 478     @ParameterizedTest
 479     @MethodSource("factories")
 480     void testJoinConfined(ThreadFactory factory) throws Exception {
 481         try (var scope = StructuredTaskScope.open(Joiner.<Boolean>awaitAll(),
 482                 cf -> cf.withThreadFactory(factory))) {
 483 
 484             // random thread cannot join
 485             try (var pool = Executors.newSingleThreadExecutor()) {
 486                 Future<Void> future = pool.submit(() -> {
 487                     assertThrows(WrongThreadException.class, scope::join);
 488                     return null;
 489                 });
 490                 future.get();
 491             }
 492 
 493             // subtask cannot join
 494             Subtask<Boolean> subtask = scope.fork(() -> {
 495                 assertThrows(WrongThreadException.class, () -> { scope.join(); });
 496                 return true;
 497             });
 498             scope.join();
 499             assertTrue(subtask.get());
 500         }
 501     }
 502 
 503     /**
 504      * Test join with interrupt status set.
 505      */
 506     @ParameterizedTest
 507     @MethodSource("factories")
 508     void testInterruptJoin1(ThreadFactory factory) throws Exception {
 509         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 510                 cf -> cf.withThreadFactory(factory))) {
 511 
 512             Subtask<String> subtask = scope.fork(() -> {
 513                 Thread.sleep(Duration.ofDays(1));
 514                 return "foo";
 515             });
 516 
 517             // join should throw
 518             Thread.currentThread().interrupt();
 519             try {
 520                 scope.join();
 521                 fail("join did not throw");
 522             } catch (InterruptedException expected) {
 523                 assertFalse(Thread.interrupted());   // interrupt status should be cleared
 524             }
 525         }
 526     }
 527 
 528     /**
 529      * Test interrupt of thread blocked in join.
 530      */
 531     @ParameterizedTest
 532     @MethodSource("factories")
 533     void testInterruptJoin2(ThreadFactory factory) throws Exception {
 534         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
 535                 cf -> cf.withThreadFactory(factory))) {


 536             Subtask<String> subtask = scope.fork(() -> {
 537                 Thread.sleep(Duration.ofDays(1));
 538                 return "foo";
 539             });
 540 
 541             // interrupt main thread when it blocks in join
 542             scheduleInterruptAt("java.util.concurrent.StructuredTaskScopeImpl.join");
 543             try {
 544                 scope.join();
 545                 fail("join did not throw");
 546             } catch (InterruptedException expected) {
 547                 assertFalse(Thread.interrupted());   // interrupt status should be clear
 548             }
 549         }
 550     }
 551 
 552     /**
 553      * Test join when scope is cancelled.
 554      */
 555     @ParameterizedTest
 556     @MethodSource("factories")
 557     void testJoinWhenCancelled(ThreadFactory factory) throws Exception {

1022     @Test
1023     void testOnCompleteCancelsExecution() throws Exception {
1024         var joiner = new Joiner<String, Void>() {
1025             @Override
1026             public boolean onComplete(Subtask<? extends String> subtask) {
1027                 return true;
1028             }
1029             @Override
1030             public Void result() {
1031                 return null;
1032             }
1033         };
1034         try (var scope = StructuredTaskScope.open(joiner)) {
1035             assertFalse(scope.isCancelled());
1036             scope.fork(() -> "foo");
1037             awaitCancelled(scope);
1038             scope.join();
1039         }
1040     }
1041 
1042     /**
1043      * Test Joiner.onTimeout invoked by owner thread when timeout expires.
1044      */
1045     @Test
1046     void testOnTimeoutInvoked() throws Exception {
1047         var scopeRef = new AtomicReference<StructuredTaskScope<?, ?>>();
1048         Thread owner = Thread.currentThread();
1049         var invokeCount = new AtomicInteger();
1050         var joiner = new Joiner<String, Void>() {
1051             @Override
1052             public void onTimeout() {
1053                 assertTrue(Thread.currentThread() == owner);
1054                 assertTrue(scopeRef.get().isCancelled());
1055                 invokeCount.incrementAndGet();
1056             }
1057             @Override
1058             public Void result() {
1059                 return null;
1060             }
1061         };
1062         try (var scope = StructuredTaskScope.open(joiner,
1063                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
1064             scopeRef.set(scope);
1065             scope.fork(() -> {
1066                 Thread.sleep(Duration.ofDays(1));
1067                 return null;
1068             });
1069             scope.join();
1070             assertEquals(1, invokeCount.get());
1071         }
1072     }
1073 
1074     /**
1075      * Test Joiner.onTimeout throwing an excepiton.
1076      */
1077     @Test
1078     void testOnTimeoutThrows() throws Exception {
1079         var joiner = new Joiner<String, Void>() {
1080             @Override
1081             public void onTimeout() {
1082                 throw new FooException();
1083             }
1084             @Override
1085             public Void result() {
1086                 return null;
1087             }
1088         };
1089         try (var scope = StructuredTaskScope.open(joiner,
1090                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
1091             // wait for scope to be cancelled by timeout
1092             awaitCancelled(scope);
1093 
1094             // join should throw FooException on first usage
1095             assertThrows(FooException.class, scope::join);
1096 
1097             // retry after onTimeout fails
1098             assertThrows(IllegalStateException.class, scope::join);
1099         }
1100     }
1101 
1102     /**
1103      * Test toString.
1104      */
1105     @Test
1106     void testToString() throws Exception {
1107         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
1108                 cf -> cf.withName("duke"))) {
1109 
1110             // open
1111             assertTrue(scope.toString().contains("duke"));
1112 
1113             // closed
1114             scope.close();
1115             assertTrue(scope.toString().contains("duke"));
1116         }
1117     }
1118 
1119     /**
1120      * Test Subtask with task that completes successfully.
1121      */
1122     @ParameterizedTest
1123     @MethodSource("factories")
1124     void testSubtaskWhenSuccess(ThreadFactory factory) throws Exception {
1125         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1126                 cf -> cf.withThreadFactory(factory))) {

1127             Subtask<String> subtask = scope.fork(() -> "foo");
1128 
1129             // before join, owner thread
1130             assertThrows(IllegalStateException.class, subtask::get);
1131             assertThrows(IllegalStateException.class, subtask::exception);
1132 
1133             // before join, another thread
1134             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::get));
1135             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::exception));
1136 
1137             scope.join();
1138 

1139             assertEquals(Subtask.State.SUCCESS, subtask.state());
1140 
1141             // after join, owner thread
1142             assertEquals("foo", subtask.get());
1143             assertThrows(IllegalStateException.class, subtask::exception);
1144 
1145             // after join, another thread
1146             assertEquals("foo", callInOtherThread(subtask::get));
1147             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::exception));
1148         }
1149     }
1150 
1151     /**
1152      * Test Subtask with task that fails.
1153      */
1154     @ParameterizedTest
1155     @MethodSource("factories")
1156     void testSubtaskWhenFailed(ThreadFactory factory) throws Exception {
1157         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1158                 cf -> cf.withThreadFactory(factory))) {
1159 
1160             Subtask<String> subtask = scope.fork(() -> { throw new FooException(); });
1161 
1162             // before join, owner thread
1163             assertThrows(IllegalStateException.class, subtask::get);
1164             assertThrows(IllegalStateException.class, subtask::exception);
1165 
1166             // before join, another thread
1167             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::get));
1168             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::exception));
1169 
1170             scope.join();
1171 

1172             assertEquals(Subtask.State.FAILED, subtask.state());
1173 
1174             // after join, owner thread
1175             assertThrows(IllegalStateException.class, subtask::get);
1176             assertTrue(subtask.exception() instanceof FooException);
1177 
1178             // after join, another thread
1179             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::get));
1180             assertTrue(callInOtherThread(subtask::exception) instanceof FooException);
1181         }
1182     }
1183 
1184     /**
1185      * Test Subtask with a task that has not completed.
1186      */
1187     @ParameterizedTest
1188     @MethodSource("factories")
1189     void testSubtaskWhenNotCompleted(ThreadFactory factory) throws Exception {
1190         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(),
1191                 cf -> cf.withThreadFactory(factory))) {
1192             Subtask<Void> subtask = scope.fork(() -> {
1193                 Thread.sleep(Duration.ofDays(1));
1194                 return null;
1195             });


1196             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());
1197 
1198             // before join, owner thread
1199             assertThrows(IllegalStateException.class, subtask::get);
1200             assertThrows(IllegalStateException.class, subtask::exception);
1201 
1202             // before join, another thread
1203             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::get));
1204             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::exception));
1205 
1206             // attempt join, join throws
1207             Thread.currentThread().interrupt();
1208             assertThrows(InterruptedException.class, scope::join);
1209 

1210             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());
1211 
1212             // after join, owner thread
1213             assertThrows(IllegalStateException.class, subtask::get);
1214             assertThrows(IllegalStateException.class, subtask::exception);
1215 
1216             // before join, another thread
1217             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::get));
1218             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::exception));
1219         }
1220     }
1221 
1222     /**
1223      * Test Subtask forked after execution cancelled.
1224      */
1225     @ParameterizedTest
1226     @MethodSource("factories")
1227     void testSubtaskWhenCancelled(ThreadFactory factory) throws Exception {
1228         try (var scope = StructuredTaskScope.open(new CancelAfterOneJoiner<String>())) {
1229             scope.fork(() -> "foo");
1230             awaitCancelled(scope);
1231 
1232             var subtask = scope.fork(() -> "foo");
1233 
1234             // before join, owner thread

1235             assertThrows(IllegalStateException.class, subtask::get);
1236             assertThrows(IllegalStateException.class, subtask::exception);
1237 
1238             // before join, another thread
1239             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::get));
1240             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::exception));
1241 
1242             scope.join();
1243 

1244             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());
1245 
1246             // after join, owner thread
1247             assertThrows(IllegalStateException.class, subtask::get);
1248             assertThrows(IllegalStateException.class, subtask::exception);
1249 
1250             // before join, another thread
1251             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::get));
1252             assertThrows(IllegalStateException.class, () -> callInOtherThread(subtask::exception));
1253         }
1254     }
1255 
1256     /**
1257      * Test Subtask::toString.
1258      */
1259     @Test
1260     void testSubtaskToString() throws Exception {
1261         try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
1262             var latch = new CountDownLatch(1);
1263             var subtask1 = scope.fork(() -> {
1264                 latch.await();
1265                 return "foo";
1266             });
1267             var subtask2 = scope.fork(() -> { throw new FooException(); });
1268 
1269             // subtask1 result is unavailable
1270             assertTrue(subtask1.toString().contains("Unavailable"));
1271             latch.countDown();
1272 

1307 
1308     /**
1309      * Test Joiner.allSuccessfulOrThrow() with a subtask that complete successfully and
1310      * a subtask that fails.
1311      */
1312     @ParameterizedTest
1313     @MethodSource("factories")
1314     void testAllSuccessfulOrThrow3(ThreadFactory factory) throws Throwable {
1315         try (var scope = StructuredTaskScope.open(Joiner.<String>allSuccessfulOrThrow(),
1316                 cf -> cf.withThreadFactory(factory))) {
1317             scope.fork(() -> "foo");
1318             scope.fork(() -> { throw new FooException(); });
1319             try {
1320                 scope.join();
1321             } catch (FailedException e) {
1322                 assertTrue(e.getCause() instanceof FooException);
1323             }
1324         }
1325     }
1326 
1327     /**
1328      * Test Joiner.allSuccessfulOrThrow() with a timeout.
1329      */
1330     @Test
1331     void testAllSuccessfulOrThrow4() throws Exception {
1332         try (var scope = StructuredTaskScope.open(Joiner.<String>allSuccessfulOrThrow(),
1333                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
1334             scope.fork(() -> "foo");
1335             scope.fork(() -> {
1336                 Thread.sleep(Duration.ofDays(1));
1337                 return "bar";
1338             });
1339             assertThrows(TimeoutException.class, scope::join);
1340 
1341             // retry after join throws TimeoutException
1342             assertThrows(IllegalStateException.class, scope::join);
1343         }
1344     }
1345 
1346     /**
1347      * Test Joiner.anySuccessfulResultOrThrow() with no subtasks.
1348      */
1349     @Test
1350     void testAnySuccessfulResultOrThrow1() throws Exception {
1351         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow())) {
1352             try {
1353                 scope.join();
1354             } catch (FailedException e) {
1355                 assertTrue(e.getCause() instanceof NoSuchElementException);
1356             }
1357         }
1358     }
1359 
1360     /**
1361      * Test Joiner.anySuccessfulResultOrThrow() with a subtask that completes successfully.
1362      */
1363     @ParameterizedTest
1364     @MethodSource("factories")
1365     void testAnySuccessfulResultOrThrow2(ThreadFactory factory) throws Exception {

1399             scope.fork(() -> { throw new FooException(); });
1400             String first = scope.join();
1401             assertEquals("foo", first);
1402         }
1403     }
1404 
1405     /**
1406      * Test Joiner.anySuccessfulResultOrThrow() with a subtask that fails.
1407      */
1408     @ParameterizedTest
1409     @MethodSource("factories")
1410     void testAnySuccessfulResultOrThrow5(ThreadFactory factory) throws Exception {
1411         try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow(),
1412                 cf -> cf.withThreadFactory(factory))) {
1413             scope.fork(() -> { throw new FooException(); });
1414             Throwable ex = assertThrows(FailedException.class, scope::join);
1415             assertTrue(ex.getCause() instanceof FooException);
1416         }
1417     }
1418 
1419     /**
1420      * Test Joiner.allSuccessfulOrThrow() with a timeout.
1421      */
1422     @Test
1423     void anySuccessfulResultOrThrow6() throws Exception {
1424         try (var scope = StructuredTaskScope.open(Joiner.<String>anySuccessfulResultOrThrow(),
1425                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
1426             scope.fork(() -> { throw new FooException(); });
1427             scope.fork(() -> {
1428                 Thread.sleep(Duration.ofDays(1));
1429                 return "bar";
1430             });
1431             assertThrows(TimeoutException.class, scope::join);
1432 
1433             // retry after join throws TimeoutException
1434             assertThrows(IllegalStateException.class, scope::join);
1435         }
1436     }
1437 
1438     /**
1439      * Test Joiner.awaitAllSuccessfulOrThrow() with no subtasks.
1440      */
1441     @Test
1442     void testAwaitSuccessfulOrThrow1() throws Throwable {
1443         try (var scope = StructuredTaskScope.open(Joiner.awaitAllSuccessfulOrThrow())) {
1444             var result = scope.join();
1445             assertNull(result);
1446         }
1447     }
1448 
1449     /**
1450      * Test Joiner.awaitAllSuccessfulOrThrow() with subtasks that complete successfully.
1451      */
1452     @ParameterizedTest
1453     @MethodSource("factories")
1454     void testAwaitSuccessfulOrThrow2(ThreadFactory factory) throws Throwable {
1455         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAllSuccessfulOrThrow(),
1456                 cf -> cf.withThreadFactory(factory))) {
1457             var subtask1 = scope.fork(() -> "foo");

1465 
1466     /**
1467      * Test Joiner.awaitAllSuccessfulOrThrow() with a subtask that complete successfully and
1468      * a subtask that fails.
1469      */
1470     @ParameterizedTest
1471     @MethodSource("factories")
1472     void testAwaitSuccessfulOrThrow3(ThreadFactory factory) throws Throwable {
1473         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAllSuccessfulOrThrow(),
1474                 cf -> cf.withThreadFactory(factory))) {
1475             scope.fork(() -> "foo");
1476             scope.fork(() -> { throw new FooException(); });
1477             try {
1478                 scope.join();
1479             } catch (FailedException e) {
1480                 assertTrue(e.getCause() instanceof FooException);
1481             }
1482         }
1483     }
1484 
1485     /**
1486      * Test Joiner.awaitAllSuccessfulOrThrow() with a timeout.
1487      */
1488     @Test
1489     void testAwaitSuccessfulOrThrow4() throws Exception {
1490         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAllSuccessfulOrThrow(),
1491                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
1492             scope.fork(() -> "foo");
1493             scope.fork(() -> {
1494                 Thread.sleep(Duration.ofDays(1));
1495                 return "bar";
1496             });
1497             assertThrows(TimeoutException.class, scope::join);
1498 
1499             // retry after join throws TimeoutException
1500             assertThrows(IllegalStateException.class, scope::join);
1501         }
1502     }
1503 
1504     /**
1505      * Test Joiner.awaitAll() with no subtasks.
1506      */
1507     @Test
1508     void testAwaitAll1() throws Throwable {
1509         try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
1510             var result = scope.join();
1511             assertNull(result);
1512         }
1513     }
1514 
1515     /**
1516      * Test Joiner.awaitAll() with subtasks that complete successfully.
1517      */
1518     @ParameterizedTest
1519     @MethodSource("factories")
1520     void testAwaitAll2(ThreadFactory factory) throws Throwable {
1521         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1522                 cf -> cf.withThreadFactory(factory))) {
1523             var subtask1 = scope.fork(() -> "foo");

1530     }
1531 
1532     /**
1533      * Test Joiner.awaitAll() with a subtask that complete successfully and a subtask
1534      * that fails.
1535      */
1536     @ParameterizedTest
1537     @MethodSource("factories")
1538     void testAwaitAll3(ThreadFactory factory) throws Throwable {
1539         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1540                 cf -> cf.withThreadFactory(factory))) {
1541             var subtask1 = scope.fork(() -> "foo");
1542             var subtask2 = scope.fork(() -> { throw new FooException(); });
1543             var result = scope.join();
1544             assertNull(result);
1545             assertEquals("foo", subtask1.get());
1546             assertTrue(subtask2.exception() instanceof FooException);
1547         }
1548     }
1549 
1550     /**
1551      * Test Joiner.awaitAll() with a timeout.
1552      */
1553     @Test
1554     void testAwaitAll4() throws Exception {
1555         try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAll(),
1556                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
1557             scope.fork(() -> "foo");
1558             scope.fork(() -> {
1559                 Thread.sleep(Duration.ofDays(1));
1560                 return "bar";
1561             });
1562             assertThrows(TimeoutException.class, scope::join);
1563 
1564             // retry after join throws TimeoutException
1565             assertThrows(IllegalStateException.class, scope::join);
1566         }
1567     }
1568 
1569     /**
1570      * Test Joiner.allUntil(Predicate) with no subtasks.
1571      */
1572     @Test
1573     void testAllUntil1() throws Throwable {
1574         try (var scope = StructuredTaskScope.open(Joiner.allUntil(s -> false))) {
1575             var subtasks = scope.join();
1576             assertEquals(0, subtasks.count());
1577         }
1578     }
1579 
1580     /**
1581      * Test Joiner.allUntil(Predicate) with no cancellation.
1582      */
1583     @ParameterizedTest
1584     @MethodSource("factories")
1585     void testAllUntil2(ThreadFactory factory) throws Exception {
1586         try (var scope = StructuredTaskScope.open(Joiner.<String>allUntil(s -> false),
1587                 cf -> cf.withThreadFactory(factory))) {
1588 
1589             var subtask1 = scope.fork(() -> "foo");
1590             var subtask2 = scope.fork(() -> { throw new FooException(); });
1591 
1592             var subtasks = scope.join().toList();
1593             assertEquals(List.of(subtask1, subtask2), subtasks);
1594 


1595             assertEquals("foo", subtask1.get());
1596             assertTrue(subtask2.exception() instanceof FooException);
1597         }
1598     }
1599 
1600     /**
1601      * Test Joiner.allUntil(Predicate) with cancellation after one subtask completes.
1602      */
1603     @ParameterizedTest
1604     @MethodSource("factories")
1605     void testAllUntil3(ThreadFactory factory) throws Exception {
1606         try (var scope = StructuredTaskScope.open(Joiner.<String>allUntil(s -> true),
1607                 cf -> cf.withThreadFactory(factory))) {
1608 
1609             var subtask1 = scope.fork(() -> "foo");
1610             var subtask2 = scope.fork(() -> {
1611                 Thread.sleep(Duration.ofDays(1));
1612                 return "bar";
1613             });
1614 
1615             var subtasks = scope.join().toList();
1616             assertEquals(List.of(subtask1, subtask2), subtasks);
1617 



1618             assertEquals("foo", subtask1.get());
1619             assertEquals(Subtask.State.UNAVAILABLE, subtask2.state());
1620         }
1621     }
1622 
1623     /**
1624      * Test Joiner.allUntil(Predicate) with cancellation after serveral subtasks complete.
1625      */
1626     @ParameterizedTest
1627     @MethodSource("factories")
1628     void testAllUntil4(ThreadFactory factory) throws Exception {
1629 
1630         // cancel execution after two or more failures
1631         class CancelAfterTwoFailures<T> implements Predicate<Subtask<? extends T>> {
1632             final AtomicInteger failedCount = new AtomicInteger();
1633             @Override
1634             public boolean test(Subtask<? extends T> subtask) {
1635                 return subtask.state() == Subtask.State.FAILED
1636                         && failedCount.incrementAndGet() >= 2;
1637             }

1660     }
1661 
1662     /**
1663      * Test Test Joiner.allUntil(Predicate) where the Predicate's test method throws.
1664      */
1665     @Test
1666     void testAllUntil5() throws Exception {
1667         var joiner = Joiner.allUntil(_ -> { throw new FooException(); });
1668         var excRef = new AtomicReference<Throwable>();
1669         Thread.UncaughtExceptionHandler uhe = (t, e) -> excRef.set(e);
1670         ThreadFactory factory = Thread.ofVirtual()
1671                 .uncaughtExceptionHandler(uhe)
1672                 .factory();
1673         try (var scope = StructuredTaskScope.open(joiner, cf -> cf.withThreadFactory(factory))) {
1674             scope.fork(() -> "foo");
1675             scope.join();
1676             assertInstanceOf(FooException.class, excRef.get());
1677         }
1678     }
1679 
1680     /**
1681      * Test Joiner.allUntil(Predicate) with a timeout.
1682      */
1683     @Test
1684     void testAllUntil6() throws Exception {
1685         try (var scope = StructuredTaskScope.open(Joiner.<String>allUntil(s -> false),
1686                 cf -> cf.withTimeout(Duration.ofMillis(100)))) {
1687             var subtask1 = scope.fork(() -> "foo");
1688             var subtask2 = scope.fork(() -> {
1689                 Thread.sleep(Duration.ofDays(1));
1690                 return "bar";
1691             });
1692 
1693             // TimeoutException should not be thrown
1694             var subtasks = scope.join().toList();
1695 
1696             // stream should have two elements, subtask1 may or may not have completed
1697             assertEquals(List.of(subtask1, subtask2), subtasks);
1698             assertEquals(Subtask.State.UNAVAILABLE, subtask2.state());
1699 
1700             // retry after join throws TimeoutException
1701             assertThrows(IllegalStateException.class, scope::join);
1702         }
1703     }
1704 
1705     /**
1706      * Test Joiner default methods.
1707      */
1708     @Test
1709     void testJoinerDefaultMethods() throws Exception {
1710         try (var scope = StructuredTaskScope.open(new CancelAfterOneJoiner<String>())) {
1711 
1712             // need subtasks to test default methods
1713             var subtask1 = scope.fork(() -> "foo");
1714             awaitCancelled(scope);
1715             var subtask2 = scope.fork(() -> "bar");
1716             scope.join();
1717 
1718             assertEquals(Subtask.State.SUCCESS, subtask1.state());
1719             assertEquals(Subtask.State.UNAVAILABLE, subtask2.state());
1720 
1721             // Joiner that does not override default methods
1722             Joiner<Object, Void> joiner = () -> null;
1723             assertThrows(NullPointerException.class, () -> joiner.onFork(null));
1724             assertThrows(NullPointerException.class, () -> joiner.onComplete(null));
1725             assertThrows(IllegalArgumentException.class, () -> joiner.onFork(subtask1));
1726             assertFalse(joiner.onFork(subtask2));
1727             assertFalse(joiner.onComplete(subtask1));
1728             assertThrows(IllegalArgumentException.class, () -> joiner.onComplete(subtask2));
1729             assertThrows(TimeoutException.class, joiner::onTimeout);
1730         }
1731     }
1732 
1733     /**
1734      * Test Joiners onFork/onComplete methods with a subtask in an unexpected state.
1735      */
1736     @Test
1737     void testJoinersWithUnavailableResult() throws Exception {
1738         try (var scope = StructuredTaskScope.open()) {
1739             var done = new CountDownLatch(1);
1740             var subtask = scope.fork(() -> {
1741                 done.await();
1742                 return null;
1743             });
1744 
1745             // onComplete with uncompleted task should throw IAE
1746             assertEquals(Subtask.State.UNAVAILABLE, subtask.state());
1747             assertThrows(IllegalArgumentException.class,
1748                     () -> Joiner.allSuccessfulOrThrow().onComplete(subtask));
1749             assertThrows(IllegalArgumentException.class,

1772                     () -> Joiner.allUntil(_ -> false).onFork(subtask));
1773         }
1774 
1775     }
1776 
1777     /**
1778      * Test the Configuration function apply method throwing an exception.
1779      */
1780     @Test
1781     void testConfigFunctionThrows() throws Exception {
1782         assertThrows(FooException.class,
1783                 () -> StructuredTaskScope.open(Joiner.awaitAll(),
1784                                                cf -> { throw new FooException(); }));
1785     }
1786 
1787     /**
1788      * Test Configuration equals/hashCode/toString
1789      */
1790     @Test
1791     void testConfigMethods() throws Exception {
1792         UnaryOperator<Configuration> configOperator = cf -> {
1793             var name = "duke";
1794             var threadFactory = Thread.ofPlatform().factory();
1795             var timeout = Duration.ofSeconds(10);
1796 
1797             assertEquals(cf, cf);
1798             assertEquals(cf.withName(name), cf.withName(name));
1799             assertEquals(cf.withThreadFactory(threadFactory), cf.withThreadFactory(threadFactory));
1800             assertEquals(cf.withTimeout(timeout), cf.withTimeout(timeout));
1801 
1802             assertNotEquals(cf, cf.withName(name));
1803             assertNotEquals(cf, cf.withThreadFactory(threadFactory));
1804             assertNotEquals(cf, cf.withTimeout(timeout));
1805 
1806             assertEquals(cf.withName(name).hashCode(), cf.withName(name).hashCode());
1807             assertEquals(cf.withThreadFactory(threadFactory).hashCode(),
1808                     cf.withThreadFactory(threadFactory).hashCode());
1809             assertEquals(cf.withTimeout(timeout).hashCode(), cf.withTimeout(timeout).hashCode());
1810 
1811             assertTrue(cf.withName(name).toString().contains(name));
1812             assertTrue(cf.withThreadFactory(threadFactory).toString().contains(threadFactory.toString()));
1813             assertTrue(cf.withTimeout(timeout).toString().contains(timeout.toString()));
1814 
1815             return cf;
1816         };
1817         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(), configOperator)) {
1818             // do nothing
1819         }
1820     }
1821 
1822     /**
1823      * Test for NullPointerException.
1824      */
1825     @Test
1826     void testNulls() throws Exception {
1827         assertThrows(NullPointerException.class,
1828                 () -> StructuredTaskScope.open(null));
1829         assertThrows(NullPointerException.class,
1830                 () -> StructuredTaskScope.open(null, cf -> cf));
1831         assertThrows(NullPointerException.class,
1832                 () -> StructuredTaskScope.open(Joiner.awaitAll(), null));
1833 
1834         assertThrows(NullPointerException.class, () -> Joiner.allUntil(null));
1835 
1836         // fork
1837         try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {

2004                 found = true;
2005             } else {
2006                 Thread.sleep(20);
2007             }
2008         }
2009         target.interrupt();
2010     }
2011 
2012     /**
2013      * Schedules the current thread to be interrupted when it waits (timed or untimed)
2014      * at the given location.
2015      */
2016     private void scheduleInterruptAt(String location) {
2017         Thread target = Thread.currentThread();
2018         scheduler.submit(() -> {
2019             interruptThreadAt(target, location);
2020             return null;
2021         });
2022     }
2023 
2024     /**
2025      * Calls a result returning task from another thread.
2026      */
2027     private <V> V callInOtherThread(Callable<V> task) throws Exception {
2028         var result = new AtomicReference<V>();
2029         var exc = new AtomicReference<Exception>();
2030         Thread thread = Thread.ofVirtual().start(() -> {
2031             try {
2032                 result.set(task.call());
2033             } catch (Exception e) {
2034                 exc.set(e);
2035             }
2036         });
2037         boolean interrupted = false;
2038         boolean terminated = false;
2039         while (!terminated) {
2040             try {
2041                 thread.join();
2042                 terminated = true;
2043             } catch (InterruptedException e) {
2044                 interrupted = true;
2045             }
2046         }
2047         if (interrupted) {
2048             Thread.currentThread().interrupt();
2049         }
2050         Exception e = exc.get();
2051         if (e != null) {
2052             throw e;
2053         } else {
2054             return result.get();
2055         }
2056     }
2057 
2058     /**
2059      * Returns true if the given stack trace contains an element for the given class
2060      * and method name.
2061      */
2062     private boolean contains(StackTraceElement[] stack, String className, String methodName) {
2063         return Arrays.stream(stack)
2064                 .anyMatch(e -> className.equals(e.getClassName())
2065                         && methodName.equals(e.getMethodName()));
2066     }
2067 }
< prev index next >