convert cache provider test to java (#14918)

Co-authored-by: Lauri Tulmin <[email protected]>

Author: zeitlinger

javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/CacheProviderTest.groovy

@@ -146,7 +146,8 @@ public AgentTypePool typePool(
     return typePool(classFileLocator, classLoader);
   }
 
-  private TypePool.CacheProvider getCacheProvider(ClassLoader classLoader) {
+  // visible for testing
+  TypePool.CacheProvider getCacheProvider(ClassLoader classLoader) {
     if (classLoader == null) {
       return bootstrapCacheProvider;
     }
@@ -167,7 +168,8 @@ private TypePool.CacheProvider getCacheProvider(ClassLoader classLoader) {
    *
    * <p>The loaderHash exists to avoid calling get & strengthening the Reference.
    */
-  private static final class TypeCacheKey {
+  // visible for testing
+  static final class TypeCacheKey {
     private final int loaderHash;
     @Nullable private final WeakReference<ClassLoader> loaderRef;
     private final String className;

muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentCachingPoolStrategy.java

@@ -0,0 +1,176 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.tooling.muzzle;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.lang.ref.WeakReference;
+import java.net.URL;
+import java.net.URLClassLoader;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.pool.TypePool;
+import org.junit.jupiter.api.Test;
+
+class CacheProviderTest {
+
+  @Test
+  void keyBootstrapEquivalence() {
+    int loaderHash = AgentCachingPoolStrategy.BOOTSTRAP_HASH;
+    WeakReference<ClassLoader> loaderRef = null;
+
+    AgentCachingPoolStrategy.TypeCacheKey key1 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef, "foo");
+    AgentCachingPoolStrategy.TypeCacheKey key2 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef, "foo");
+
+    assertThat(key1).hasSameHashCodeAs(key2).isEqualTo(key2);
+  }
+
+  @Test
+  void keySameRefEquivalence() {
+    ClassLoader loader = newClassLoader();
+    int loaderHash = loader.hashCode();
+    WeakReference<ClassLoader> loaderRef = new WeakReference<>(loader);
+
+    AgentCachingPoolStrategy.TypeCacheKey key1 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef, "foo");
+    AgentCachingPoolStrategy.TypeCacheKey key2 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef, "foo");
+
+    assertThat(key1).hasSameHashCodeAs(key2).isEqualTo(key2);
+    // use loader to ensures that it isn't collected before the test completes
+    assertThat(loader).isNotNull();
+  }
+
+  @Test
+  void keyDifferentRefEquivalence() {
+    ClassLoader loader = newClassLoader();
+    int loaderHash = loader.hashCode();
+    WeakReference<ClassLoader> loaderRef1 = new WeakReference<>(loader);
+    WeakReference<ClassLoader> loaderRef2 = new WeakReference<>(loader);
+
+    AgentCachingPoolStrategy.TypeCacheKey key1 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef1, "foo");
+    AgentCachingPoolStrategy.TypeCacheKey key2 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef2, "foo");
+
+    assertThat(loaderRef1).isNotSameAs(loaderRef2);
+
+    assertThat(key1).hasSameHashCodeAs(key2).isEqualTo(key2);
+    // use loader to ensures that it isn't collected before the test completes
+    assertThat(loader).isNotNull();
+  }
+
+  @Test
+  void keyMismatchSameLoaderDifferentName() {
+    ClassLoader loader = newClassLoader();
+    int loaderHash = loader.hashCode();
+    WeakReference<ClassLoader> loaderRef = new WeakReference<>(loader);
+    AgentCachingPoolStrategy.TypeCacheKey fooKey =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef, "foo");
+    AgentCachingPoolStrategy.TypeCacheKey barKey =
+        new AgentCachingPoolStrategy.TypeCacheKey(loaderHash, loaderRef, "bar");
+
+    // not strictly guaranteed -- but important for performance
+    assertThat(fooKey.hashCode()).isNotEqualTo(barKey.hashCode());
+    assertThat(fooKey).isNotEqualTo(barKey);
+    // use loader to ensures that it isn't collected before the test completes
+    assertThat(loader).isNotNull();
+  }
+
+  @Test
+  void keyMismatchSameNameDifferentLoader() {
+    ClassLoader loader1 = newClassLoader();
+    int loader1Hash = loader1.hashCode();
+    WeakReference<ClassLoader> loaderRef1 = new WeakReference<>(loader1);
+
+    ClassLoader loader2 = newClassLoader();
+    int loader2Hash = loader2.hashCode();
+    WeakReference<ClassLoader> loaderRef2 = new WeakReference<>(loader2);
+
+    AgentCachingPoolStrategy.TypeCacheKey fooKey1 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loader1Hash, loaderRef1, "foo");
+    AgentCachingPoolStrategy.TypeCacheKey fooKey2 =
+        new AgentCachingPoolStrategy.TypeCacheKey(loader2Hash, loaderRef2, "foo");
+
+    // not strictly guaranteed -- but important for performance
+    assertThat(fooKey1.hashCode()).isNotEqualTo(fooKey2.hashCode());
+    assertThat(fooKey1).isNotEqualTo(fooKey2);
+    // use loader to ensures that it isn't collected before the test completes
+    assertThat(loader1).isNotNull();
+    assertThat(loader2).isNotNull();
+  }
+
+  @Test
+  void testBasicCaching() {
+    AgentCachingPoolStrategy poolStrat = new AgentCachingPoolStrategy(null);
+
+    ClassLoader loader = newClassLoader();
+
+    TypePool.CacheProvider cacheProvider = poolStrat.getCacheProvider(loader);
+
+    cacheProvider.register(
+        "foo", new TypePool.Resolution.Simple(TypeDescription.ForLoadedType.of(void.class)));
+
+    // not strictly guaranteed, but fine for this test
+    assertThat(cacheProvider.find("foo")).isNotNull();
+    // use loader to ensures that it isn't collected before the test completes
+    assertThat(loader).isNotNull();
+  }
+
+  @Test
+  void testLoaderEquivalence() {
+    AgentCachingPoolStrategy poolStrat = new AgentCachingPoolStrategy(null);
+
+    ClassLoader loader1 = newClassLoader();
+
+    TypePool.CacheProvider cacheProvider1A = poolStrat.getCacheProvider(loader1);
+    TypePool.CacheProvider cacheProvider1B = poolStrat.getCacheProvider(loader1);
+
+    cacheProvider1A.register("foo", newVoid());
+
+    // not strictly guaranteed, but fine for this test
+    assertThat(cacheProvider1A.find("foo")).isNotNull();
+    assertThat(cacheProvider1B.find("foo")).isNotNull();
+
+    assertThat(cacheProvider1A.find("foo")).isSameAs(cacheProvider1B.find("foo"));
+
+    // use loader to ensures that it isn't collected before the test completes
+    assertThat(loader1).isNotNull();
+  }
+
+  @Test
+  void testLoaderSeparation() {
+    AgentCachingPoolStrategy poolStrat = new AgentCachingPoolStrategy(null);
+
+    ClassLoader loader1 = newClassLoader();
+    ClassLoader loader2 = newClassLoader();
+
+    TypePool.CacheProvider cacheProvider1 = poolStrat.getCacheProvider(loader1);
+    TypePool.CacheProvider cacheProvider2 = poolStrat.getCacheProvider(loader2);
+
+    cacheProvider1.register("foo", newVoid());
+    cacheProvider2.register("foo", newVoid());
+
+    // not strictly guaranteed, but fine for this test
+    assertThat(cacheProvider1.find("foo")).isNotNull();
+    assertThat(cacheProvider2.find("foo")).isNotNull();
+
+    assertThat(cacheProvider1.find("foo")).isNotSameAs(cacheProvider2.find("foo"));
+
+    // use loader to ensures that it isn't collected before the test completes
+    assertThat(loader1).isNotNull();
+    assertThat(loader2).isNotNull();
+  }
+
+  private static TypePool.Resolution newVoid() {
+    return new TypePool.Resolution.Simple(TypeDescription.ForLoadedType.of(void.class));
+  }
+
+  private static ClassLoader newClassLoader() {
+    return new URLClassLoader(new URL[0], null);
+  }
+}