Properly test glassfish helpers during build-time muzzle checks (#10114)

The glassfish helpers require package-private access to an interface, so must be injected into the glassfish class-loader.
At runtime this is achieved via the instrumentation-based class-injector. We can simulate this for the build-time muzzle
checks by granting the same access via reflection.

Author: mcculls

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/MuzzleVersionScanPlugin.java

@@ -8,6 +8,7 @@
 import de.thetaphi.forbiddenapis.SuppressForbidden;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -16,6 +17,7 @@
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.function.BiConsumer;
 import net.bytebuddy.dynamic.ClassFileLocator;
 
 /**
@@ -75,9 +77,9 @@ public static void assertInstrumentationMuzzled(
           // verify helper consistency
           final String[] helperClassNames = module.helperClassNames();
           if (helperClassNames.length > 0) {
-            HelperClassLoader helperClassLoader = new HelperClassLoader(testApplicationLoader);
+            BiConsumer<String, byte[]> injectClassHelper = injectClassHelper(testApplicationLoader);
             for (Map.Entry<String, byte[]> helper : createHelperMap(module).entrySet()) {
-              helperClassLoader.injectClass(helper.getKey(), helper.getValue());
+              injectClassHelper.accept(helper.getKey(), helper.getValue());
             }
           }
         } catch (final Throwable e) {
@@ -90,6 +92,29 @@ public static void assertInstrumentationMuzzled(
     }
   }
 
+  /** Simulates instrumentation-based access to defineClass feature. */
+  private static BiConsumer<String, byte[]> injectClassHelper(ClassLoader cl) {
+    try {
+      Method findLoadedClass = ClassLoader.class.getDeclaredMethod("findLoadedClass", String.class);
+      Method defineClass =
+          ClassLoader.class.getDeclaredMethod(
+              "defineClass", String.class, byte[].class, int.class, int.class);
+      findLoadedClass.setAccessible(true);
+      defineClass.setAccessible(true);
+      return (name, bytes) -> {
+        try {
+          if (findLoadedClass.invoke(cl, name) == null) {
+            defineClass.invoke(cl, name, bytes, 0, bytes.length);
+          }
+        } catch (ReflectiveOperationException e) {
+          throw new RuntimeException(e);
+        }
+      };
+    } catch (ReflectiveOperationException e) {
+      return new HelperClassLoader(cl)::injectClass;
+    }
+  }
+
   // build modules to test while single-threaded to match installer assumptions
   private static synchronized List<InstrumenterModule> toBeTested(
       ClassLoader instrumentationLoader, String muzzleDirective) {
@@ -114,7 +139,9 @@ static final class HelperClassLoader extends ClassLoader {
     }
 
     public void injectClass(String name, byte[] bytecode) {
-      defineClass(name, bytecode, 0, bytecode.length);
+      if (findLoadedClass(name) == null) {
+        defineClass(name, bytecode, 0, bytecode.length);
+      }
     }
   }