diff --git a/src/test/java/com/android/tools/r8/D8TestCompileResult.java b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
index 3908d64..6d7634c 100644
--- a/src/test/java/com/android/tools/r8/D8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
@@ -5,10 +5,7 @@
 
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.utils.AndroidApp;
-import java.io.IOException;
-import java.nio.file.Path;
 import java.util.Set;
-import java.util.concurrent.ExecutionException;
 
 public class D8TestCompileResult extends TestCompileResult<D8TestCompileResult, D8TestRunResult> {
   private final String proguardMap;
@@ -57,13 +54,4 @@
   public D8TestRunResult createRunResult(TestRuntime runtime, ProcessResult result) {
     return new D8TestRunResult(app, runtime, result, proguardMap);
   }
-
-  public D8TestRunResult runWithJaCoCo(
-      Path output, TestRuntime runtime, String mainClass, String... args)
-      throws IOException, ExecutionException {
-    setSystemProperty("jacoco-agent.destfile", output.toString());
-    setSystemProperty("jacoco-agent.dumponexit", "true");
-    setSystemProperty("jacoco-agent.output", "file");
-    return run(runtime, mainClass, args);
-  }
 }
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
index ebf30b6..5b6996d 100644
--- a/src/test/java/com/android/tools/r8/TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -217,6 +217,14 @@
         ObjectArrays.concat(mainClassSubject.getFinalName(), args));
   }
 
+  public RR runWithJaCoCo(Path output, TestRuntime runtime, String mainClass, String... args)
+      throws IOException, ExecutionException {
+    setSystemProperty("jacoco-agent.destfile", output.toString());
+    setSystemProperty("jacoco-agent.dumponexit", "true");
+    setSystemProperty("jacoco-agent.output", "file");
+    return run(runtime, mainClass, args);
+  }
+
   public CR addRunClasspathFiles(Path... classpath) {
     return addRunClasspathFiles(Arrays.asList(classpath));
   }
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/ConstantDynamicGetDeclaredMethodsTest.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/ConstantDynamicGetDeclaredMethodsTest.java
new file mode 100644
index 0000000..de9685e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/ConstantDynamicGetDeclaredMethodsTest.java
@@ -0,0 +1,154 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.constantdynamic;
+
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.DesugarTestConfiguration;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.cf.CfVersion;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Method;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ConstantDynamicGetDeclaredMethodsTest extends TestBase {
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build());
+  }
+
+  private static final String EXPECTED_OUTPUT =
+      StringUtils.lines(
+          "Hello, world!",
+          "myConstant",
+          "3",
+          "java.lang.invoke.MethodHandles$Lookup",
+          "java.lang.String",
+          "java.lang.Class");
+  private static final String EXPECTED_OUTPUT_R8 =
+      StringUtils.lines("Hello, world!", "No myConstant method");
+
+  private static final Class<?> MAIN_CLASS = A.class;
+
+  @Test
+  public void testReference() throws Exception {
+    assumeTrue(parameters.isCfRuntime());
+    assumeTrue(parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11));
+    assumeTrue(parameters.getApiLevel().isEqualTo(AndroidApiLevel.B));
+
+    testForJvm()
+        .addProgramClassFileData(getTransformedClasses())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testDesugaring() throws Exception {
+    testForDesugaring(parameters)
+        .addProgramClassFileData(getTransformedClasses())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        // TODO(b/210485236): This should never fail.
+        .applyIf(
+            // When not desugaring the CF code requires JDK 11.
+            DesugarTestConfiguration::isNotDesugared,
+            r -> {
+              if (parameters.isCfRuntime()
+                  && parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11)) {
+                r.assertSuccessWithOutput(EXPECTED_OUTPUT);
+              } else {
+                r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class);
+              }
+            },
+            c ->
+                DesugarTestConfiguration.isDesugared(c)
+                    && parameters.isDexRuntime()
+                    && parameters.asDexRuntime().getVersion().isOlderThan(Version.V8_1_0),
+            r -> r.assertFailureWithErrorThatThrows(ClassNotFoundException.class),
+            r -> r.assertSuccessWithOutput(EXPECTED_OUTPUT));
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(getTransformedClasses())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_CLASS)
+        .applyIf(
+            parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+            b -> b.addDontWarn(MethodHandles.Lookup.class))
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT_R8);
+  }
+
+  @Test
+  public void testR8KeepBootstrapMethod() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    testForR8(parameters.getBackend())
+        .addProgramClassFileData(getTransformedClasses())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_CLASS)
+        .addKeepMethodRules(MAIN_CLASS, "myConstant(...)")
+        .applyIf(
+            parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+            b -> b.addDontWarn(MethodHandles.Lookup.class))
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        // TODO(b/210485236): This should never fail.
+        .applyIf(
+            parameters.getDexRuntimeVersion().isOlderThan(Version.V8_1_0),
+            b -> b.assertFailureWithErrorThatThrows(ClassNotFoundException.class),
+            b -> b.assertSuccessWithOutput(EXPECTED_OUTPUT));
+  }
+
+  private byte[] getTransformedClasses() throws IOException {
+    return transformer(A.class)
+        .setVersion(CfVersion.V11)
+        .transformConstStringToConstantDynamic(
+            "condy", A.class, "myConstant", "constantName", Object.class)
+        .transform();
+  }
+
+  public static class A {
+
+    public static Object f() {
+      return "condy"; // Will be transformed to Constant_DYNAMIC.
+    }
+
+    public static void main(String[] args) {
+      System.out.println(f());
+      Method[] methods = A.class.getDeclaredMethods();
+      for (Method method : methods) {
+        if (method.getName().equals("myConstant")) {
+          System.out.println(method.getName());
+          System.out.println(method.getParameterTypes().length);
+          for (int j = 0; j < method.getParameterTypes().length; j++) {
+            System.out.println(method.getParameterTypes()[j].getName());
+          }
+          return;
+        }
+      }
+      System.out.println("No myConstant method");
+    }
+
+    private static Object myConstant(MethodHandles.Lookup lookup, String name, Class<?> type) {
+      return "Hello, world!";
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
new file mode 100644
index 0000000..79fc834
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/constantdynamic/JacocoConstantDynamicGetDeclaredMethods.java
@@ -0,0 +1,193 @@
+// Copyright (c) 2021, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.desugar.constantdynamic;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.cf.CfVersion;
+import com.android.tools.r8.jacoco.JacocoClasses;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.StringUtils;
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Method;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class JacocoConstantDynamicGetDeclaredMethods extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+  }
+
+  public static final String jacocoBootstrapMethodName = "$jacocoInit";
+
+  public static JacocoClasses testClasses;
+
+  private static final String MAIN_CLASS = TestRunner.class.getTypeName();
+  private static final String EXPECTED_OUTPUT =
+      StringUtils.lines(
+          jacocoBootstrapMethodName,
+          "3",
+          "java.lang.invoke.MethodHandles$Lookup",
+          "java.lang.String",
+          "java.lang.Class");
+
+  @BeforeClass
+  public static void setUpInput() throws IOException {
+    testClasses = testClasses(getStaticTemp());
+  }
+
+  private void checkJacocoReport(Path agentOutput) throws IOException {
+    // TODO(sgjesse): Need to figure out why there is no instrumentation output for newer VMs.
+    if (parameters.isCfRuntime()
+        || parameters.getRuntime().asDex().getVm().isOlderThanOrEqual(DexVm.ART_4_4_4_HOST)) {
+      assertEquals(2, testClasses.generateReport(agentOutput).size());
+    } else {
+      assertFalse(Files.exists(agentOutput));
+    }
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    assumeTrue(
+        parameters.isCfRuntime()
+            && (parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK11)));
+
+    // Run non-instrumented code with an agent causing on the fly instrumentation on the JVM.
+    Path output = temp.newFolder().toPath();
+    Path agentOutputOnTheFly = output.resolve("on-the-fly");
+    testForJvm()
+        .addProgramFiles(testClasses.getOriginal())
+        .enableJaCoCoAgent(ToolHelper.JACOCO_AGENT, agentOutputOnTheFly)
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+    checkJacocoReport(agentOutputOnTheFly);
+
+    // Run the instrumented code.
+    Path agentOutputOffline = output.resolve("offline");
+    testForJvm()
+        .addProgramFiles(testClasses.getInstrumented())
+        .configureJaCoCoAgentForOfflineInstrumentedCode(ToolHelper.JACOCO_AGENT, agentOutputOffline)
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+    checkJacocoReport(agentOutputOffline);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue(parameters.getRuntime().isDex());
+    Path agentOutput = temp.newFolder().toPath().resolve("jacoco.exec");
+    testForD8(parameters.getBackend())
+        .addProgramFiles(testClasses.getInstrumented())
+        .addProgramFiles(ToolHelper.JACOCO_AGENT)
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .runWithJaCoCo(agentOutput, parameters.getRuntime(), MAIN_CLASS)
+        // TODO(b/210485236): This should never fail.
+        .applyIf(
+            parameters.getDexRuntimeVersion().isOlderThan(Version.V8_1_0),
+            b -> b.assertFailureWithErrorThatThrows(ClassNotFoundException.class),
+            b -> b.assertSuccessWithOutput(EXPECTED_OUTPUT));
+    checkJacocoReport(agentOutput);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    assumeTrue(parameters.getRuntime().isDex());
+    Path agentOutput = temp.newFolder().toPath().resolve("jacoco.exec");
+    testForR8(parameters.getBackend())
+        .addProgramFiles(testClasses.getInstrumented())
+        .addProgramFiles(ToolHelper.JACOCO_AGENT)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRules(TestRunner.class)
+        .applyIf(
+            parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+            b -> b.addDontWarn(MethodHandles.Lookup.class))
+        .addDontWarn("java.lang.management.ManagementFactory", "javax.management.**")
+        .compile()
+        .runWithJaCoCo(agentOutput, parameters.getRuntime(), MAIN_CLASS)
+        .inspect(
+            inspector -> {
+              assertThat(
+                  inspector.clazz(TestRunner.class).uniqueMethodWithName(jacocoBootstrapMethodName),
+                  isAbsent());
+            })
+        .assertSuccessWithOutputLines("No " + jacocoBootstrapMethodName + " method");
+    checkJacocoReport(agentOutput);
+  }
+
+  @Test
+  public void testR8KeepingJacocoInit() throws Exception {
+    assumeTrue(parameters.getRuntime().isDex());
+    Path agentOutput = temp.newFolder().toPath().resolve("jacoco.exec");
+    testForR8(parameters.getBackend())
+        .addProgramFiles(testClasses.getInstrumented())
+        .addProgramFiles(ToolHelper.JACOCO_AGENT)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRules(TestRunner.class)
+        .addKeepRules("-keep class ** { *** " + jacocoBootstrapMethodName + "(...); }")
+        .applyIf(
+            parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
+            b -> b.addDontWarn(MethodHandles.Lookup.class))
+        .addDontWarn(
+            "java.lang.instrument.ClassFileTransformer",
+            "java.lang.management.ManagementFactory",
+            "javax.management.**")
+        .compile()
+        .runWithJaCoCo(agentOutput, parameters.getRuntime(), MAIN_CLASS)
+        // TODO(b/210485236): This should never fail.
+        .applyIf(
+            parameters.getDexRuntimeVersion().isOlderThan(Version.V8_1_0),
+            b -> b.assertFailureWithErrorThatThrows(ClassNotFoundException.class),
+            b -> b.assertSuccessWithOutput(EXPECTED_OUTPUT));
+    checkJacocoReport(agentOutput);
+  }
+
+  private static JacocoClasses testClasses(TemporaryFolder temp) throws IOException {
+    return new JacocoClasses(
+        transformer(TestRunner.class).setVersion(CfVersion.V11).transform(), temp);
+  }
+
+  static class TestRunner {
+
+    public static void main(String[] args) {
+      Method[] methods = TestRunner.class.getDeclaredMethods();
+      for (Method method : methods) {
+        if (method.getName().equals(jacocoBootstrapMethodName)) {
+          System.out.println(method.getName());
+          System.out.println(method.getParameterTypes().length);
+          for (int j = 0; j < method.getParameterTypes().length; j++) {
+            System.out.println(method.getParameterTypes()[j].getName());
+          }
+          return;
+        }
+      }
+      System.out.println("No " + jacocoBootstrapMethodName + " method");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/jacoco/JacocoClasses.java b/src/test/java/com/android/tools/r8/jacoco/JacocoClasses.java
index 0149669..b98cc63 100644
--- a/src/test/java/com/android/tools/r8/jacoco/JacocoClasses.java
+++ b/src/test/java/com/android/tools/r8/jacoco/JacocoClasses.java
@@ -22,6 +22,7 @@
 // Two sets of class files with and without JaCoCo offline instrumentation.
 public class JacocoClasses {
 
+  private final TemporaryFolder temp;
   private final Path dir;
 
   private final Path originalJar;
@@ -29,6 +30,7 @@
 
   // Create JacocoClasses with just one class provided as bytes.
   public JacocoClasses(byte[] clazz, TemporaryFolder temp) throws IOException {
+    this.temp = temp;
     dir = temp.newFolder().toPath();
 
     // Write the class to a .class file with package sub-directories.
@@ -62,7 +64,7 @@
   }
 
   public List<String> generateReport(Path jacocoExec) throws IOException {
-    Path report = dir.resolve("report.scv");
+    Path report = temp.newFolder().toPath().resolve("report.scv");
     ProcessResult result = ToolHelper.runJaCoCoReport(originalJar, jacocoExec, report);
     assertEquals(result.toString(), 0, result.exitCode);
     return Files.readAllLines(report);