Tweak tests

Author: daniellansun

src/test/groovy/org/apache/groovy/runtime/async/AsyncConcurrencyTest.groovy

@@ -23,6 +23,7 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
 import org.junit.jupiter.api.DisplayName
 
+import java.io.IOException
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.CyclicBarrier
 import java.util.concurrent.TimeUnit
@@ -503,13 +504,13 @@ class AsyncConcurrencyTest {
     void testMoveNextPropagatesExceptionViaSneakyThrow() {
         def gen = new AsyncStreamGenerator<Integer>()
         Thread.start {
-            gen.error(new java.io.IOException("disk fail"))
+            gen.error(new IOException("disk fail"))
         }
 
         try {
             gen.moveNext().get()
             assert false : "Expected IOException"
-        } catch (java.io.IOException e) {
+        } catch (IOException e) {
             assert e.message == "disk fail"
         }
     }

src/test/groovy/org/codehaus/groovy/transform/AsyncApiTest.groovy

@@ -18,6 +18,7 @@
  */
 package org.codehaus.groovy.transform
 
+import groovy.concurrent.AsyncScope
 import groovy.concurrent.AsyncStream
 import groovy.concurrent.AwaitResult
 import groovy.concurrent.Awaitable
@@ -29,17 +30,24 @@ import org.apache.groovy.runtime.async.GroovyPromise
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Test
 
+import java.lang.reflect.InvocationTargetException
 import java.util.concurrent.Callable
 import java.util.concurrent.CancellationException
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.CompletionException
 import java.util.concurrent.CompletionStage
+import java.util.concurrent.ConcurrentLinkedQueue
 import java.util.concurrent.CountDownLatch
+import java.util.concurrent.CyclicBarrier
 import java.util.concurrent.ExecutionException
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
 import java.util.concurrent.Flow
+import java.util.concurrent.Future
 import java.util.concurrent.FutureTask
 import java.util.concurrent.SubmissionPublisher
 import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicReference
@@ -150,15 +158,15 @@ class AsyncApiTest {
     void testAwaitPlainFutureSuccess() {
         def ft = new FutureTask<String>({ 'hello' } as Callable<String>)
         ft.run()
-        assert AsyncSupport.await((java.util.concurrent.Future<String>) ft) == 'hello'
+        assert AsyncSupport.await((Future<String>) ft) == 'hello'
     }
 
     @Test
     void testAwaitPlainFutureFailed() {
         def ft = new FutureTask<String>({ throw new IOException('future-error') } as Callable<String>)
         ft.run()
         try {
-            AsyncSupport.await((java.util.concurrent.Future<String>) ft)
+            AsyncSupport.await((Future<String>) ft)
             assert false
         } catch (IOException e) {
             assert e.message == 'future-error'
@@ -170,7 +178,7 @@ class AsyncApiTest {
         def ft = new FutureTask<String>({ 'never' } as Callable<String>)
         ft.cancel(true)
         try {
-            AsyncSupport.await((java.util.concurrent.Future<String>) ft)
+            AsyncSupport.await((Future<String>) ft)
             assert false
         } catch (CancellationException ignored) {}
     }
@@ -185,7 +193,7 @@ class AsyncApiTest {
         // Don't run it — it will block on get(), and we set interrupt
         Thread.currentThread().interrupt()
         try {
-            AsyncSupport.await((java.util.concurrent.Future<String>) ft)
+            AsyncSupport.await((Future<String>) ft)
             assert false
         } catch (CancellationException e) {
             assert e.message.contains('Interrupted')
@@ -199,7 +207,7 @@ class AsyncApiTest {
     void testAwaitFutureWithCompletableFuture() {
         // Pass CF as Future to hit line 245: instanceof CompletableFuture shortcut
         def cf = CompletableFuture.completedFuture('via-cf')
-        assert AsyncSupport.await((java.util.concurrent.Future<String>) cf) == 'via-cf'
+        assert AsyncSupport.await((Future<String>) cf) == 'via-cf'
     }
 
     @Test
@@ -297,7 +305,7 @@ class AsyncApiTest {
         def ft = new FutureTask<String>({ throw new ArithmeticException('div-zero') } as Callable<String>)
         ft.run()
         try {
-            AsyncSupport.await((java.util.concurrent.Future<String>) ft)
+            AsyncSupport.await((Future<String>) ft)
             assert false
         } catch (ArithmeticException e) {
             assert e.message == 'div-zero'
@@ -1042,7 +1050,7 @@ class AsyncApiTest {
     void testCloseInterruptsBlockedProducerThread() {
         def gen = new AsyncStreamGenerator<Integer>()
         def producerExit = new CompletableFuture<String>()
-        def producerBlocked = new java.util.concurrent.CountDownLatch(1)
+        def producerBlocked = new CountDownLatch(1)
 
         def producerThread = Thread.start {
             gen.attachProducer(Thread.currentThread())
@@ -1094,7 +1102,7 @@ class AsyncApiTest {
     void testCloseInterruptsBlockedConsumerThread() {
         def gen = new AsyncStreamGenerator<Integer>()
         def consumerResult = new CompletableFuture<Boolean>()
-        def consumerBlocked = new java.util.concurrent.CountDownLatch(1)
+        def consumerBlocked = new CountDownLatch(1)
 
         // Start a consumer thread that will block in moveNext()
         // because no producer will ever yield anything
@@ -1367,7 +1375,7 @@ class AsyncApiTest {
         def toAwaitable = builtInClass.getDeclaredMethod('toAwaitable', Object)
         toAwaitable.accessible = true
 
-        def ex = shouldFail(java.lang.reflect.InvocationTargetException) {
+        def ex = shouldFail(InvocationTargetException) {
             toAwaitable.invoke(adapter, new Object())
         }
         assert ex.cause instanceof IllegalArgumentException
@@ -1384,7 +1392,7 @@ class AsyncApiTest {
         def toAsyncStream = builtInClass.getDeclaredMethod('toAsyncStream', Object)
         toAsyncStream.accessible = true
 
-        def ex = shouldFail(java.lang.reflect.InvocationTargetException) {
+        def ex = shouldFail(InvocationTargetException) {
             toAsyncStream.invoke(adapter, 123)
         }
         assert ex.cause instanceof IllegalArgumentException
@@ -2040,13 +2048,13 @@ class AsyncApiTest {
             assert false
         } catch (Exception e) {
             // IOException wrapped in ExecutionException, then unwrapped
-            assert e instanceof IOException || e instanceof java.util.concurrent.ExecutionException
+            assert e instanceof IOException || e instanceof ExecutionException
         }
     }
 
     @Test
     void testFutureAdapterInterruptedFutureMapsToCancellation() {
-        def interruptedFuture = new java.util.concurrent.Future<String>() {
+        def interruptedFuture = new Future<String>() {
             boolean cancel(boolean mayInterruptIfRunning) { false }
             boolean isCancelled() { false }
             boolean isDone() { true }
@@ -2062,7 +2070,7 @@ class AsyncApiTest {
 
     @Test
     void testFutureAdapterCancellationExceptionIsPropagated() {
-        def cancelledFuture = new java.util.concurrent.Future<String>() {
+        def cancelledFuture = new Future<String>() {
             boolean cancel(boolean mayInterruptIfRunning) { false }
             boolean isCancelled() { true }
             boolean isDone() { true }
@@ -2078,7 +2086,7 @@ class AsyncApiTest {
 
     @Test
     void testFutureAdapterUnexpectedExceptionIsPropagated() {
-        def brokenFuture = new java.util.concurrent.Future<String>() {
+        def brokenFuture = new Future<String>() {
             boolean cancel(boolean mayInterruptIfRunning) { false }
             boolean isCancelled() { false }
             boolean isDone() { true }
@@ -2113,7 +2121,7 @@ class AsyncApiTest {
     void testGetSetExecutor() {
         def original = AsyncSupport.getExecutor()
         assert original != null
-        def custom = { Runnable r -> r.run() } as java.util.concurrent.Executor
+        def custom = { Runnable r -> r.run() } as Executor
         AsyncSupport.setExecutor(custom)
         assert AsyncSupport.getExecutor().is(custom)
         AsyncSupport.setExecutor(null) // reset
@@ -2402,7 +2410,7 @@ class AsyncApiTest {
         def ex = shouldFail(ExecutionException) {
             withTimeout.get()
         }
-        assert ex.cause instanceof java.util.concurrent.TimeoutException
+        assert ex.cause instanceof TimeoutException
     }
 
     @Test
@@ -2413,7 +2421,7 @@ class AsyncApiTest {
         def ex = shouldFail(ExecutionException) {
             withTimeout.get()
         }
-        assert ex.cause instanceof java.util.concurrent.TimeoutException
+        assert ex.cause instanceof TimeoutException
     }
 
     @Test
@@ -2469,7 +2477,7 @@ class AsyncApiTest {
     void testGroovyPromiseGetWithTimeoutExpired() {
         def cf = new CompletableFuture<>()
         def promise = GroovyPromise.of(cf)
-        shouldFail(java.util.concurrent.TimeoutException) {
+        shouldFail(TimeoutException) {
             promise.get(50, TimeUnit.MILLISECONDS)
         }
     }
@@ -2690,7 +2698,7 @@ class AsyncApiTest {
         def ex = shouldFail(ExecutionException) {
             aw.get()
         }
-        assert ex.cause instanceof java.util.concurrent.TimeoutException
+        assert ex.cause instanceof TimeoutException
     }
 
     @Test
@@ -2716,7 +2724,7 @@ class AsyncApiTest {
         def original = Awaitable.getExecutor()
         assert original != null
         try {
-            def custom = java.util.concurrent.Executors.newSingleThreadExecutor()
+            def custom = Executors.newSingleThreadExecutor()
             Awaitable.setExecutor(custom)
             assert Awaitable.getExecutor().is(custom)
             custom.shutdown()
@@ -3169,7 +3177,7 @@ class AsyncApiTest {
     void testAbstractAsyncStreamGeneratorBeforeTakeRejectsSecondConsumer() {
         // AsyncStreamGenerator.beforeTake() enforces single-consumer semantics
         def gen = new AsyncStreamGenerator<Integer>()
-        def latch = new java.util.concurrent.CountDownLatch(1)
+        def latch = new CountDownLatch(1)
         def error = new CompletableFuture<Throwable>()
 
         CompletableFuture.runAsync {
@@ -3344,8 +3352,8 @@ class AsyncApiTest {
     void testAdapterCacheConcurrentAccess() {
         // Hammer the cache from multiple threads to verify thread safety
         int threadCount = 32
-        def barrier = new java.util.concurrent.CyclicBarrier(threadCount)
-        def errors = new java.util.concurrent.ConcurrentLinkedQueue<Throwable>()
+        def barrier = new CyclicBarrier(threadCount)
+        def errors = new ConcurrentLinkedQueue<Throwable>()
         def threads = (1..threadCount).collect { idx ->
             Thread.start {
                 try {
@@ -3442,7 +3450,7 @@ class AsyncApiTest {
 
     @Test
     void testAsyncScopeBasicUsage() {
-        def result = groovy.concurrent.AsyncScope.withScope { scope ->
+        def result = AsyncScope.withScope { scope ->
             def a = scope.async { 10 }
             def b = scope.async { 20 }
             return a.get() + b.get()
@@ -3456,7 +3464,7 @@ class AsyncApiTest {
         def error = null
 
         try {
-            groovy.concurrent.AsyncScope.withScope { scope ->
+            AsyncScope.withScope { scope ->
                 // Slow task
                 scope.async {
                     try {
@@ -3484,7 +3492,7 @@ class AsyncApiTest {
     @Test
     void testAsyncScopeAggregatesSuppressedExceptions() {
         try {
-            groovy.concurrent.AsyncScope.withScope { scope ->
+            AsyncScope.withScope { scope ->
                 scope.async { throw new IllegalArgumentException("err1") }
                 scope.async { throw new IllegalStateException("err2") }
                 Thread.sleep(200)  // Let both fail
@@ -3502,7 +3510,7 @@ class AsyncApiTest {
 
     @Test
     void testAsyncScopeRejectsAfterClose() {
-        def scope = new groovy.concurrent.AsyncScope()
+        def scope = new AsyncScope()
         scope.close()
         shouldFail(IllegalStateException) {
             scope.async { 42 }
@@ -3511,7 +3519,7 @@ class AsyncApiTest {
 
     @Test
     void testAsyncScopeChildCount() {
-        groovy.concurrent.AsyncScope.withScope { scope ->
+        AsyncScope.withScope { scope ->
             assert scope.childCount == 0
             scope.async { 1 }
             scope.async { 2 }
@@ -3524,7 +3532,7 @@ class AsyncApiTest {
     @Test
     void testAsyncScopeHighConcurrency() {
         int taskCount = 10_000
-        def result = groovy.concurrent.AsyncScope.withScope { scope ->
+        def result = AsyncScope.withScope { scope ->
             def tasks = (1..taskCount).collect { n ->
                 scope.async { n }
             }
@@ -3539,7 +3547,7 @@ class AsyncApiTest {
 
     @Test
     void testAsyncScopeCloseIsIdempotent() {
-        def scope = new groovy.concurrent.AsyncScope()
+        def scope = new AsyncScope()
         def task = scope.async { 42 }
         assert task.get() == 42
         scope.close()

src/test/groovy/org/codehaus/groovy/transform/AsyncAwaitSyntaxTest.groovy

@@ -1421,6 +1421,7 @@ class AsyncAwaitSyntaxTest {
     void testAsyncWithCustomExecutor() {
         assertScript '''
             import java.util.concurrent.Executors
+            import groovy.concurrent.Awaitable
 
             class Svc {
                 static executor = Executors.newFixedThreadPool(2)
@@ -1429,12 +1430,12 @@ class AsyncAwaitSyntaxTest {
                 }
             }
 
-            groovy.concurrent.Awaitable.setExecutor(Svc.executor)
+            Awaitable.setExecutor(Svc.executor)
             try {
                 def name = new Svc().threadInfo().get()
                 assert name.contains("pool")
             } finally {
-                groovy.concurrent.Awaitable.setExecutor(null)
+                Awaitable.setExecutor(null)
                 Svc.executor.shutdown()
             }
         '''
@@ -1643,29 +1644,6 @@ class AsyncAwaitSyntaxTest {
     // 6. Error cases — syntax and semantic rejections
     // =====================================================================
 
-    @Test
-    void testAsyncOnAbstractMethodFails() {
-        def err = shouldFail CompilationFailedException, '''
-            abstract class Svc {
-                @groovy.transform.Async
-                abstract def compute()
-            }
-        '''
-        assert err.message.contains('cannot be applied to abstract method')
-    }
-
-    @Test
-    void testAsyncOnAwaitableReturnTypeFails() {
-        def err = shouldFail CompilationFailedException, '''
-            import groovy.concurrent.Awaitable
-            class Svc {
-                @groovy.transform.Async
-                Awaitable<String> compute() { Awaitable.of("x") }
-            }
-        '''
-        assert err.message.contains('already returns an async type')
-    }
-
     @Test
     void testForAwaitWithTraditionalForSyntaxFails() {
         def err = shouldFail CompilationFailedException, '''
@@ -2471,9 +2449,11 @@ class AsyncAwaitSyntaxTest {
     @Test
     void testYieldReturnOutsideAsyncMethodFails() {
         assertScript '''
+            import org.apache.groovy.runtime.async.AsyncSupport
+
             // yield return outside async method should fail at runtime
             try {
-                org.apache.groovy.runtime.async.AsyncSupport.yieldReturn("oops")
+                AsyncSupport.yieldReturn("oops")
                 assert false : "expected exception"
             } catch (IllegalStateException e) {
                 assert e.message.contains("yield return")