daniellansun commented on code in PR #3298:
URL: https://github.com/apache/groovy/pull/3298#discussion_r4571277648
##########
src/test/groovy/groovy/AsyncAwaitTest.groovy:
##########
@@ -4115,17 +4115,228 @@ final class AsyncAwaitTest {
}
@Test
- void testScopeCloseWithCheckedExceptionWrapped() {
+ void testScopeCloseRethrowsCheckedExceptionUnwrapped() {
assertScript '''
import groovy.concurrent.AsyncScope
def scope = AsyncScope.create()
- scope.async { throw new Exception('checked-err') }
+ scope.async { throw new IOException('checked-err') }
try {
scope.close()
assert false
- } catch (RuntimeException e) {
- assert e.cause.message == 'checked-err'
+ } catch (IOException e) {
+ assert e.message == 'checked-err'
+ }
+ '''
+ }
+
+ // Checked exceptions surface as themselves from every async construct, as
from await
+
+ @Test
+ void testWithScopeChildCheckedExceptionTransparency() {
+ assertScript '''
+ import groovy.concurrent.AsyncScope
+
+ try {
+ AsyncScope.withScope { scope ->
+ scope.async { throw new IOException('child') }
+ null
+ }
+ assert false
+ } catch (IOException e) {
+ assert e.message == 'child'
+ }
+ '''
+ }
+
+ @Test
+ void testWithScopeBodyCheckedExceptionTransparency() {
+ assertScript '''
+ import groovy.concurrent.AsyncScope
+ import java.time.Duration
+
+ try {
+ AsyncScope.withScope { scope -> throw new IOException('body') }
+ assert false
+ } catch (IOException e) {
+ assert e.message == 'body'
+ }
+ try {
+ AsyncScope.withScope(Duration.ofSeconds(5)) { scope -> throw
new IOException('timed body') }
+ assert false
+ } catch (IOException e) {
+ assert e.message == 'timed body'
+ }
+ '''
+ }
+
+ @Test
+ void testWithScopeBodyKeepsAWrapperTheCodeThrew() {
+ assertScript '''
+ import groovy.concurrent.AsyncScope
+ import java.util.concurrent.ExecutionException
+
+ try {
+ AsyncScope.withScope { scope -> throw new
ExecutionException(new IOException('inner')) }
+ assert false
+ } catch (ExecutionException e) {
+ assert e.cause instanceof IOException
+ }
+ '''
+ }
+
+ @Test
+ void testGeneratorKeepsAWrapperTheCodeThrew() {
+ assertScript '''
+ import java.util.concurrent.ExecutionException
+
+ def gen = async {
+ yield return 1
+ throw new ExecutionException(new IOException('inner'))
+ }
+ try {
+ for (x in gen) { }
+ assert false
+ } catch (ExecutionException e) {
+ assert e.cause instanceof IOException
+ }
+ '''
+ }
+
+ @Test
+ void testDeferCheckedExceptionTransparency() {
+ assertScript '''
+ try {
+ await async {
+ defer { throw new IOException('cleanup') }
+ 1
+ }
+ assert false
+ } catch (IOException e) {
+ assert e.message == 'cleanup'
+ }
+ '''
+ }
+
+ @Test
+ void testGeneratorCheckedExceptionTransparency() {
+ assertScript '''
+ def gen = async {
+ yield return 1
+ throw new IOException('gen')
+ }
+ def seen = []
+ try {
+ for (x in gen) { seen << x }
+ assert false
+ } catch (IOException e) {
+ assert e.message == 'gen'
+ }
+ assert seen == [1]
+ '''
+ }
+
+ @Test
+ void testFlowPublisherCheckedExceptionTransparency() {
+ assertScript '''
+ import java.util.concurrent.SubmissionPublisher
+
+ def pub = new SubmissionPublisher<Integer>()
+ def seen = []
+ def producer = Thread.start {
+ while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+ pub.submit(1)
+ // closeExceptionally may overtake an undelivered item
+ while (pub.estimateMaximumLag() > 0) Thread.onSpinWait()
+ pub.closeExceptionally(new IOException('flow'))
+ }
+ try {
+ for await (x in pub) { seen << x }
+ assert false
+ } catch (IOException e) {
+ assert e.message == 'flow'
+ }
+ producer.join()
+ assert seen == [1]
+ '''
+ }
+
+ @Test
+ void testFlowPublisherKeepsAWrapperTheCodeThrew() {
+ assertScript '''
+ import java.util.concurrent.ExecutionException
+ import java.util.concurrent.SubmissionPublisher
+
+ def pub = new SubmissionPublisher<Integer>()
+ def producer = Thread.start {
+ while (pub.numberOfSubscribers == 0) Thread.onSpinWait()
+ pub.closeExceptionally(new ExecutionException(new
IOException('inner')))
+ }
+ try {
+ for await (x in pub) { }
+ assert false
+ } catch (ExecutionException e) {
+ assert e.cause instanceof IOException
+ }
+ producer.join()
+ '''
+ }
+
+ // A wrapper thrown by a child task or deferred action is removed, exactly
as await removes it
+
+ @Test
+ void testScopeChildAndDeferUnwrapAsAwaitDoes() {
+ assertScript '''
+ import groovy.concurrent.AsyncScope
+ import java.util.concurrent.ExecutionException
+ import static groovy.test.GroovyAssert.shouldFail
+
+ def wrapped = { new ExecutionException(new IOException('inner')) }
+ def viaAwait = shouldFail(IOException) { await async { throw
wrapped() } }
+ def viaChild = shouldFail(IOException) {
+ AsyncScope.withScope { scope -> scope.async { throw wrapped()
}; null }
+ }
+ def viaDefer = shouldFail(IOException) {
+ await async { defer { throw wrapped() }; 1 }
+ }
+ assert [viaAwait, viaChild, viaDefer]*.message == ['inner'] * 3
+ '''
+ }
+
+ @Test
+ void testCheckedExceptionTransparencyUnderCompileStatic() {
+ assertScript '''
+ import groovy.concurrent.AsyncScope
+ import groovy.transform.CompileStatic
+ import static groovy.test.GroovyAssert.shouldFail
+
+ @CompileStatic
+ class Paths {
+ static void child() {
+ AsyncScope.withScope { AsyncScope scope -> scope.async {
throw new IOException('child') }; null }
+ }
+ static void body() {
+ AsyncScope.withScope { AsyncScope scope -> throw new
IOException('body') }
+ }
+ static void deferred() {
+ await async { defer { throw new IOException('defer') }; 1 }
+ }
+ static void generator() {
+ def gen = async { yield return 1; throw new
IOException('gen') }
+ for (x in gen) { }
+ }
+ }
+
+ ['child', 'body', 'defer', 'gen'].eachWithIndex { String msg, int
i ->
+ def e = shouldFail(IOException) {
+ switch (i) {
+ case 0 -> Paths.child()
+ case 1 -> Paths.body()
+ case 2 -> Paths.deferred()
+ default -> Paths.generator()
+ }
+ }
+ assert e.message == msg
}
Review Comment:
Thorough regression suite—especially spinning on `pub.estimateMaximumLag() >
0` before `closeExceptionally` to avoid `SubmissionPublisher` race flakiness!
Three targeted additions would round out the test matrix nicely:
1. **`@CompileStatic` parity for `for await` and timed `withScope`:**
`Paths` above exercises `child`, `body`, `defer`, and `generator` under
`@CompileStatic`, while `FlowPublisherAdapter` (`for await`) and
`withScope(Duration, ...)` are currently only covered in dynamic mode.
2. **Timed `withScope(Duration, ...)` shared-failure & timeout-cause
tests:** Testing a shared checked `IOException` awaited by both a timed
`withScope(Duration.ofSeconds(5))` body and its child task (regression test for
`withScopeTimeout`'s `try-with-resources` self-suppression), plus verifying
`TimeoutException.getCause()` is `InterruptedException` rather than
`UndeclaredThrowableException` when a dynamic timed scope expires.
3. **Suppressed-exception preservation across wrapper removal:** Verifying
that when an outer wrapper (such as `ExecutionException(new
IOException('primary'))` in a `defer` block followed by another `defer`
throwing `IOException('cleanup')`) is unwrapped, `'cleanup'` remains attached
to `primary.getSuppressed()`.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]