Remove reflection from structured concurrency test (open-telemetry#11304)

Author: laurit

instrumentation/executors/jdk21-testing/build.gradle.kts

@@ -1,3 +1,5 @@
+import kotlin.math.max
+
 plugins {
   id("otel.javaagent-testing")
 }
@@ -10,11 +12,28 @@ dependencies {
 }
 
 otelJava {
-  minJavaVersionSupported.set(JavaVersion.VERSION_21)
+  // StructuredTaskScopeTest that uses preview feature, requires that the test is compiled for the
+  // same vm version that is going to execute the test. Choose whichever is greater 21 or the
+  // version of the vm that is going to run test
+  val testJavaVersion =
+    gradle.startParameter.projectProperties["testJavaVersion"]?.let(JavaVersion::toVersion)
+      ?: JavaVersion.current()
+  minJavaVersionSupported.set(JavaVersion.toVersion(max(
+    testJavaVersion.majorVersion.toInt(),
+    JavaVersion.VERSION_21.majorVersion.toInt()
+  )))
+}
+
+tasks.withType<JavaCompile>().configureEach {
+  with(options) {
+    compilerArgs.add("--enable-preview")
+  }
 }
 
 tasks.withType<Test>().configureEach {
   // needed for VirtualThreadTest
   jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED")
   jvmArgs("-XX:+IgnoreUnrecognizedVMOptions")
+  // needed for structured concurrency test
+  jvmArgs("--enable-preview")
 }

instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/StructuredTaskScopeTest.java renamed to instrumentation/executors/jdk21-testing/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/StructuredTaskScopeTest.java

@@ -10,31 +10,20 @@
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
-import java.lang.reflect.Method;
 import java.util.concurrent.Callable;
+import java.util.concurrent.StructuredTaskScope;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.EnabledForJreRange;
-import org.junit.jupiter.api.condition.JRE;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
-@EnabledForJreRange(min = JRE.JAVA_21)
+@SuppressWarnings("preview")
 class StructuredTaskScopeTest {
 
   @RegisterExtension
   static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
 
   @Test
   void multipleForkJoin() throws Exception {
-    Class<?> sofTaskScopeClass =
-        Class.forName("java.util.concurrent.StructuredTaskScope$ShutdownOnFailure");
-    Object taskScope = sofTaskScopeClass.getDeclaredConstructor().newInstance();
-    Class<?> taskScopeClass = Class.forName("java.util.concurrent.StructuredTaskScope");
-    Method forkMethod = taskScopeClass.getDeclaredMethod("fork", Callable.class);
-    Method joinMethod = taskScopeClass.getDeclaredMethod("join");
-    Method closeMethod = taskScopeClass.getDeclaredMethod("close");
-
-    Class<?> subtaskClass = Class.forName("java.util.concurrent.StructuredTaskScope$Subtask");
-    Method getMethod = subtaskClass.getDeclaredMethod("get");
+    StructuredTaskScope<Object> taskScope = new StructuredTaskScope.ShutdownOnFailure();
 
     Callable<String> callable1 =
         () -> {
@@ -51,15 +40,11 @@ void multipleForkJoin() throws Exception {
         testing.runWithSpan(
             "parent",
             () -> {
-              try {
-                Object fork1 = forkMethod.invoke(taskScope, callable1);
-                Object fork2 = forkMethod.invoke(taskScope, callable2);
-                joinMethod.invoke(taskScope);
+              StructuredTaskScope.Subtask<String> fork1 = taskScope.fork(callable1);
+              StructuredTaskScope.Subtask<String> fork2 = taskScope.fork(callable2);
+              taskScope.join();
 
-                return "" + getMethod.invoke(fork1) + getMethod.invoke(fork2);
-              } catch (Exception e) {
-                throw new AssertionError(e);
-              }
+              return "" + fork1.get() + fork2.get();
             });
 
     assertThat(result).isEqualTo("ab");
@@ -73,6 +58,6 @@ void multipleForkJoin() throws Exception {
                 span ->
                     span.hasName("task2").hasKind(SpanKind.INTERNAL).hasParent(trace.getSpan(0))));
 
-    closeMethod.invoke(taskScope);
+    taskScope.close();
   }
 }