feat(java-concurrent): Add smoke test for Thread.ofVirtualThread()

Author: PerfectSlayer

dd-smoke-tests/concurrent/java-21/src/main/java/datadog/smoketest/concurrent/ConcurrentApp.java

@@ -17,6 +17,7 @@ public static void main(String[] args) {
 
   private static FibonacciCalculator getCalculator(String name) {
     return switch (name) {
+      case "virtualThreadStart" -> new VirtualThreadStartCalculator();
       case "virtualThreadExecute" -> new VirtualThreadExecuteCalculator();
       case "virtualThreadSubmitRunnable" -> new VirtualThreadSubmitRunnableCalculator();
       case "virtualThreadSubmitCallable" -> new VirtualThreadSubmitCallableCalculator();

dd-smoke-tests/concurrent/java-21/src/main/java/datadog/smoketest/concurrent/VirtualThreadExecuteCalculator.java

@@ -20,6 +20,11 @@ public long computeFibonacci(int n) throws ExecutionException, InterruptedExcept
     return task.result.get();
   }
 
+  @Override
+  public void close() {
+    this.executor.shutdown();
+  }
+
   public class FibonacciExecuteTask implements Runnable {
     private final long n;
     private final CompletableFuture<Long> result;
@@ -46,9 +51,4 @@ public void run() {
       }
     }
   }
-
-  @Override
-  public void close() {
-    this.executor.shutdown();
-  }
 }

dd-smoke-tests/concurrent/java-21/src/main/java/datadog/smoketest/concurrent/VirtualThreadInvokeAllCalculator.java

@@ -23,6 +23,11 @@ public long computeFibonacci(int n) throws ExecutionException, InterruptedExcept
     return this.executor.invokeAll(of(task)).getFirst().get();
   }
 
+  @Override
+  public void close() {
+    this.executor.shutdown();
+  }
+
   public class FibonacciSubmitTask implements Callable<Long> {
     private final long n;
 
@@ -41,9 +46,4 @@ public Long call() throws ExecutionException, InterruptedException {
       return futures.getFirst().get() + futures.getLast().get();
     }
   }
-
-  @Override
-  public void close() {
-    this.executor.shutdown();
-  }
 }

dd-smoke-tests/concurrent/java-21/src/main/java/datadog/smoketest/concurrent/VirtualThreadInvokeAnyCalculator.java

@@ -21,6 +21,11 @@ public long computeFibonacci(int n) throws ExecutionException, InterruptedExcept
     return this.executor.invokeAny(of(task));
   }
 
+  @Override
+  public void close() {
+    this.executor.shutdown();
+  }
+
   public class FibonacciSubmitTask implements Callable<Long> {
     private final long n;
 
@@ -38,9 +43,4 @@ public Long call() throws ExecutionException, InterruptedException {
       return executor.invokeAny(of(task1)) + executor.invokeAny(of(task2));
     }
   }
-
-  @Override
-  public void close() {
-    this.executor.shutdown();
-  }
 }

dd-smoke-tests/concurrent/java-21/src/main/java/datadog/smoketest/concurrent/VirtualThreadStartCalculator.java

@@ -0,0 +1,45 @@
+package datadog.smoketest.concurrent;
+
+import io.opentelemetry.instrumentation.annotations.WithSpan;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class VirtualThreadStartCalculator implements FibonacciCalculator {
+  @Override
+  public long computeFibonacci(int n) throws ExecutionException, InterruptedException {
+    FibonacciExecuteTask task = new FibonacciExecuteTask(n);
+    Thread.startVirtualThread(task);
+    return task.result.get();
+  }
+
+  @Override
+  public void close() {
+  }
+
+  public static class FibonacciExecuteTask implements Runnable {
+    private final long n;
+    private final CompletableFuture<Long> result;
+
+    public FibonacciExecuteTask(long n) {
+      this.n = n;
+      this.result = new CompletableFuture<>();
+    }
+
+    @WithSpan("compute")
+    public void run() {
+      if (this.n <= 1) {
+        this.result.complete(this.n);
+        return;
+      }
+      FibonacciExecuteTask task1 = new FibonacciExecuteTask(this.n - 1);
+      FibonacciExecuteTask task2 = new FibonacciExecuteTask(this.n - 2);
+      Thread.startVirtualThread(task1);
+      Thread.startVirtualThread(task2);
+      try {
+        this.result.complete(task1.result.get() + task2.result.get());
+      } catch (InterruptedException | ExecutionException e) {
+        this.result.completeExceptionally(e);
+      }
+    }
+  }
+}

dd-smoke-tests/concurrent/java-21/src/main/java/datadog/smoketest/concurrent/VirtualThreadSubmitCallableCalculator.java

@@ -20,6 +20,11 @@ public long computeFibonacci(int n) throws ExecutionException, InterruptedExcept
     return this.executor.submit(task).get();
   }
 
+  @Override
+  public void close() {
+    this.executor.shutdown();
+  }
+
   public class FibonacciSubmitTask implements Callable<Long> {
     private final long n;
 
@@ -39,9 +44,4 @@ public Long call() throws ExecutionException, InterruptedException {
       return future1.get() + future2.get();
     }
   }
-
-  @Override
-  public void close() {
-    this.executor.shutdown();
-  }
 }

dd-smoke-tests/concurrent/java-21/src/main/java/datadog/smoketest/concurrent/VirtualThreadSubmitRunnableCalculator.java

@@ -20,6 +20,11 @@ public long computeFibonacci(int n) throws ExecutionException, InterruptedExcept
     return task.result.get();
   }
 
+  @Override
+  public void close() {
+    this.executor.shutdown();
+  }
+
   public class FibonacciSubmitTask implements Runnable {
     private final long n;
     private final CompletableFuture<Long> result;
@@ -46,9 +51,4 @@ public void run() {
       }
     }
   }
-
-  @Override
-  public void close() {
-    this.executor.shutdown();
-  }
 }

dd-smoke-tests/concurrent/java-21/src/test/groovy/datadog/smoketest/concurrent/VirtualThreadTest.groovy

@@ -1,5 +1,17 @@
 package datadog.smoketest.concurrent
 
+class VirtualThreadStartTest extends AbstractConcurrentTest {
+  @Override
+  protected List<String> getTestArguments() {
+    return ['virtualThreadStart']
+  }
+
+  def 'test Thread.startVirtualThread() runnable'() {
+    expect:
+    receivedCorrectTrace()
+  }
+}
+
 class VirtualThreadExecuteTest extends AbstractConcurrentTest {
   @Override
   protected List<String> getTestArguments() {