Avoid warning when dynamic attach is enabled with JVM flag (#3551)

raphw · web-flow · commit cd4704a5caa5 · 2024-12-19T13:56:10.000+01:00
Fixes #3512
diff --git a/mockito-core/src/main/java/org/mockito/Mockito.java b/mockito-core/src/main/java/org/mockito/Mockito.java
@@ -244,6 +244,11 @@
  * &lt;/plugin&gt;
  * </code></pre>
  *
+ * <p>
+ * To enable support for dynamic attach, it is also possible to start a JVM with
+ * <pre>-XX:+EnableDynamicAgentLoading</pre>. Do however note that, since this option is not standardized, any future
+ * release of a JDK might prohibit this behaviour.
+ *
  * <h3 id="1">1. <a class="meaningful_link" href="#verification" name="verification">Let's verify some behaviour!</a></h3>
  *
  * The following examples mock a List, because most people are familiar with the interface (such as the
diff --git a/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java b/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java
@@ -9,12 +9,18 @@
 import net.bytebuddy.agent.Installer;
 
 import java.lang.instrument.Instrumentation;
+import java.util.List;
 
 import static org.mockito.internal.util.StringUtil.join;
 
 public class PremainAttachAccess {
 
+    private static volatile Instrumentation inst;
+
     public static Instrumentation getInstrumentation() {
+        if (inst != null) {
+            return inst;
+        }
         // A Java agent is always added to the system class loader. If Mockito is executed from a
         // different class loader we need to make sure to resolve the instrumentation instance
         // from there, or fail the resolution, if this class does not exist on the system class
@@ -34,16 +40,41 @@ public static Instrumentation getInstrumentation() {
         }
         if (instrumentation == null) {
             if (ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V21)) {
-                // Cannot use `Plugins.getMockitoLogger().warn(...)` at this time due to a circular
-                // dependency on `Plugins.registry`.
-                // The `PluginRegistry` is not yet fully initialized (in `Plugins`), because it is
-                // currently initializing the `MockMaker` which is a InlineByteBuddyMockMaker, and
-                // it is later calling this method to access the instrumentation.
-                System.err.println(
-                        "Mockito is currently self-attaching to enable the inline-mock-maker. This "
-                                + "will no longer work in future releases of the JDK. Please add Mockito as an agent to your "
-                                + "build as described in Mockito's documentation: "
-                                + "https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#0.3");
+                boolean dynamicAgentLoading;
+                try {
+                    Object runtimeMXBean =
+                            Class.forName("java.lang.management.ManagementFactory")
+                                    .getMethod("getRuntimeMXBean")
+                                    .invoke(null);
+                    @SuppressWarnings("unchecked")
+                    List<String> arguments =
+                            (List<String>)
+                                    runtimeMXBean
+                                            .getClass()
+                                            .getMethod("getInputArguments")
+                                            .invoke(runtimeMXBean);
+                    dynamicAgentLoading =
+                            arguments.stream()
+                                    .anyMatch(
+                                            argument ->
+                                                    argument.contains(
+                                                            "-XX:+EnableDynamicAgentLoading"));
+                } catch (Exception ignored) {
+                    dynamicAgentLoading = false;
+                }
+                if (!dynamicAgentLoading) {
+                    // Cannot use `Plugins.getMockitoLogger().warn(...)` at this time due to a
+                    // circular dependency on `Plugins.registry`.
+                    // The `PluginRegistry` is not yet fully initialized (in `Plugins`), because it
+                    // is currently initializing the `MockMaker` which is a
+                    // InlineByteBuddyMockMaker, and it is later calling this
+                    // method to access the instrumentation.
+                    System.err.println(
+                            "Mockito is currently self-attaching to enable the inline-mock-maker. This "
+                                    + "will no longer work in future releases of the JDK. Please add Mockito as an agent to your "
+                                    + "build as described in Mockito's documentation: "
+                                    + "https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#0.3");
+                }
             }
             // Attempt to dynamically attach, as a last resort.
             instrumentation = ByteBuddyAgent.install();
@@ -55,6 +86,7 @@ public static Instrumentation getInstrumentation() {
                             "",
                             "You cannot use this mock maker on this VM"));
         }
+        inst = instrumentation;
         return instrumentation;
     }
 
diff --git a/mockito-integration-tests/java-21-tests/build.gradle.kts b/mockito-integration-tests/java-21-tests/build.gradle.kts
@@ -32,6 +32,7 @@ tasks {
                 // "-Djdk.instrument.traceUsage",
             )
         }
+        failIfStdErrWarningOnDynamicallyLoadedAgent(this)
     }
 
     val testWithMockitoAgent by registering(Test::class) {
@@ -51,10 +52,23 @@ tasks {
         failIfStdErrWarningOnDynamicallyLoadedAgent(this)
     }
 
+    val testWithEnableDynamicAgentLoading by registering(Test::class) {
+        if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)) {
+            enabled = false
+        } else {
+            jvmArgs(
+                "-XX:+EnableDynamicAgentLoading",
+                // "-Djdk.instrument.traceUsage",
+            )
+        }
+        failIfStdErrWarningOnDynamicallyLoadedAgent(this)
+    }
+
     named<Test>("test") {
         dependsOn(
             testWithMockitoAgent,
             testWithBytebuddyAgent,
+            testWithEnableDynamicAgentLoading,
         )
         isEnabled = JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)
 

Original file line number	Diff line number	Diff line change
`@@ -244,6 +244,11 @@`
`244`	`244`	`* </plugin>`
`245`	`245`	`* </code></pre>`
`246`	`246`	`*`
	`247`	`+ * <p>`
	`248`	`+ * To enable support for dynamic attach, it is also possible to start a JVM with`
	`249`	`+ * <pre>-XX:+EnableDynamicAgentLoading</pre>. Do however note that, since this option is not standardized, any future`
	`250`	`+ * release of a JDK might prohibit this behaviour.`
	`251`	`+ *`
`247`	`252`	`* <h3 id="1">1. <a class="meaningful_link" href="#verification" name="verification">Let's verify some behaviour!</a></h3>`
`248`	`253`	`*`
`249`	`254`	`* The following examples mock a List, because most people are familiar with the interface (such as the`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ tasks {`
`32`	`32`	`// "-Djdk.instrument.traceUsage",`
`33`	`33`	`)`
`34`	`34`	`}`
	`35`	`+ failIfStdErrWarningOnDynamicallyLoadedAgent(this)< 57AE /code>`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`val testWithMockitoAgent by registering(Test::class) {`
`@@ -51,10 +52,23 @@ tasks {`
`51`	`52`	`failIfStdErrWarningOnDynamicallyLoadedAgent(this)`
`52`	`53`	`}`
`53`	`54`
	`55`	`+ val testWithEnableDynamicAgentLoading by registering(Test::class) {`
	`56`	`+ if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)) {`
	`57`	`+ enabled = false`
	`58`	`+ } else {`
	`59`	`+ jvmArgs(`
	`60`	`+ "-XX:+EnableDynamicAgentLoading",`
	`61`	`+ // "-Djdk.instrument.traceUsage",`
	`62`	`+ )`
	`63`	`+ }`
	`64`	`+ failIfStdErrWarningOnDynamicallyLoadedAgent(this)`
	`65`	`+ }`
	`66`	`+`
`54`	`67`	`named<Test>("test") {`
`55`	`68`	`dependsOn(`
`56`	`69`	`testWithMockitoAgent,`
`57`	`70`	`testWithBytebuddyAgent,`
	`71`	`+ testWithEnableDynamicAgentLoading,`
`58`	`72`	`)`
`59`	`73`	`isEnabled = JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)`
`60`	`74`