diff --git a/src/main/java/com/android/tools/r8/utils/FileUtils.java b/src/main/java/com/android/tools/r8/utils/FileUtils.java
index 19fc10a..20bde1a 100644
--- a/src/main/java/com/android/tools/r8/utils/FileUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/FileUtils.java
@@ -45,8 +45,8 @@
     return name.endsWith(VDEX_EXTENSION);
   }
 
-  public static boolean isClassFile(Path path) {
-    String name = path.getFileName().toString().toLowerCase();
+  public static boolean isClassFile(String path) {
+    String name = path.toLowerCase();
     // Android does not support Java 9 module, thus skip module-info.
     if (name.equals(MODULE_INFO_CLASS)) {
       return false;
@@ -54,6 +54,10 @@
     return name.endsWith(CLASS_EXTENSION);
   }
 
+  public static boolean isClassFile(Path path) {
+    return isClassFile(path.getFileName().toString());
+  }
+
   public static boolean isJarFile(Path path) {
     String name = path.getFileName().toString().toLowerCase();
     return name.endsWith(JAR_EXTENSION);
@@ -74,6 +78,11 @@
     return name.endsWith(AAR_EXTENSION);
   }
 
+  public static boolean isJavaFile(Path path) {
+    String name = path.getFileName().toString().toLowerCase();
+    return name.endsWith(JAVA_EXTENSION);
+  }
+
   public static boolean isArchive(Path path) {
     String name = path.getFileName().toString().toLowerCase();
     return name.endsWith(APK_EXTENSION)
diff --git a/src/main/java/com/android/tools/r8/utils/ZipUtils.java b/src/main/java/com/android/tools/r8/utils/ZipUtils.java
index da688a8..e0863ce 100644
--- a/src/main/java/com/android/tools/r8/utils/ZipUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ZipUtils.java
@@ -33,6 +33,7 @@
 import java.util.Set;
 import java.util.Spliterator;
 import java.util.Spliterators;
+import java.util.function.BiFunction;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
@@ -84,6 +85,31 @@
     }
   }
 
+  public static Path map(
+      Path zipFilePath, Path mappedFilePath, BiFunction<ZipEntry, byte[], byte[]> map)
+      throws IOException {
+    ZipBuilder builder = ZipBuilder.builder(mappedFilePath);
+    ZipUtils.iter(
+        zipFilePath,
+        ((entry, input) -> {
+          builder.addBytes(entry.getName(), map.apply(entry, ByteStreams.toByteArray(input)));
+        }));
+    return builder.build();
+  }
+
+  public static Path filter(Path zipFilePath, Path filteredFilePath, Predicate<ZipEntry> predicate)
+      throws IOException {
+    ZipBuilder builder = ZipBuilder.builder(filteredFilePath);
+    ZipUtils.iter(
+        zipFilePath,
+        ((entry, input) -> {
+          if (predicate.test(entry)) {
+            builder.addBytes(entry.getName(), ByteStreams.toByteArray(input));
+          }
+        }));
+    return builder.build();
+  }
+
   public static byte[] readSingleEntry(Path zipFilePath, String name) throws IOException {
     try (ZipFile zipFile = new ZipFile(zipFilePath.toFile(), StandardCharsets.UTF_8)) {
       return ByteStreams.toByteArray(zipFile.getInputStream(zipFile.getEntry(name)));
diff --git a/src/test/examplesDagger/basic/I1.java b/src/test/examplesDagger/basic/I1.java
new file mode 100644
index 0000000..cd46afa
--- /dev/null
+++ b/src/test/examplesDagger/basic/I1.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2022, 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 basic;
+
+interface I1 {
+  String getName();
+}
diff --git a/src/test/examplesDagger/basic/I1Impl1.java b/src/test/examplesDagger/basic/I1Impl1.java
new file mode 100644
index 0000000..635a35f
--- /dev/null
+++ b/src/test/examplesDagger/basic/I1Impl1.java
@@ -0,0 +1,17 @@
+// Copyright (c) 2022, 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 basic;
+
+import javax.inject.Inject;
+
+// @Singleton (added by transformer in some tests)
+public class I1Impl1 implements I1 {
+
+  @Inject
+  public I1Impl1() {}
+
+  public String getName() {
+    return "I1Impl1";
+  }
+}
diff --git a/src/test/examplesDagger/basic/I1Impl2.java b/src/test/examplesDagger/basic/I1Impl2.java
new file mode 100644
index 0000000..ed33281
--- /dev/null
+++ b/src/test/examplesDagger/basic/I1Impl2.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2022, 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 basic;
+
+public class I1Impl2 implements I1 {
+
+  public I1Impl2() {}
+
+  public String getName() {
+    return "I1Impl2";
+  }
+}
diff --git a/src/test/examplesDagger/basic/I2.java b/src/test/examplesDagger/basic/I2.java
new file mode 100644
index 0000000..51948ee
--- /dev/null
+++ b/src/test/examplesDagger/basic/I2.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2022, 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 basic;
+
+interface I2 {
+  String getName();
+}
diff --git a/src/test/examplesDagger/basic/I2Impl1.java b/src/test/examplesDagger/basic/I2Impl1.java
new file mode 100644
index 0000000..13f8b9a
--- /dev/null
+++ b/src/test/examplesDagger/basic/I2Impl1.java
@@ -0,0 +1,17 @@
+// Copyright (c) 2022, 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 basic;
+
+import javax.inject.Inject;
+
+// @Singleton (added by transformer in some tests)
+public class I2Impl1 implements I2 {
+
+  @Inject
+  public I2Impl1() {}
+
+  public String getName() {
+    return "I2Impl1";
+  }
+}
diff --git a/src/test/examplesDagger/basic/I2Impl2.java b/src/test/examplesDagger/basic/I2Impl2.java
new file mode 100644
index 0000000..e1a5da7
--- /dev/null
+++ b/src/test/examplesDagger/basic/I2Impl2.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2022, 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 basic;
+
+public class I2Impl2 implements I2 {
+
+  public I2Impl2() {}
+
+  public String getName() {
+    return "I2Impl2";
+  }
+}
diff --git a/src/test/examplesDagger/basic/I3.java b/src/test/examplesDagger/basic/I3.java
new file mode 100644
index 0000000..154a47b
--- /dev/null
+++ b/src/test/examplesDagger/basic/I3.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2022, 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 basic;
+
+interface I3 {
+  String getName();
+}
diff --git a/src/test/examplesDagger/basic/I3Impl1.java b/src/test/examplesDagger/basic/I3Impl1.java
new file mode 100644
index 0000000..560113b
--- /dev/null
+++ b/src/test/examplesDagger/basic/I3Impl1.java
@@ -0,0 +1,17 @@
+// Copyright (c) 2022, 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 basic;
+
+import javax.inject.Inject;
+
+// @Singleton (added by transformer in some tests)
+public class I3Impl1 implements I3 {
+
+  @Inject
+  public I3Impl1() {}
+
+  public String getName() {
+    return "I3Impl1";
+  }
+}
diff --git a/src/test/examplesDagger/basic/I3Impl2.java b/src/test/examplesDagger/basic/I3Impl2.java
new file mode 100644
index 0000000..99bdede
--- /dev/null
+++ b/src/test/examplesDagger/basic/I3Impl2.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2022, 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 basic;
+
+public class I3Impl2 implements I3 {
+
+  public I3Impl2() {}
+
+  public String getName() {
+    return "I3Impl2";
+  }
+}
diff --git a/src/test/examplesDagger/basic/MainBase.java b/src/test/examplesDagger/basic/MainBase.java
new file mode 100644
index 0000000..d1ad6f3
--- /dev/null
+++ b/src/test/examplesDagger/basic/MainBase.java
@@ -0,0 +1,18 @@
+// Copyright (c) 2022, 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 basic;
+
+public class MainBase {
+  public void test(MainComponent mainComponent) {
+    I1 i1 = mainComponent.i1();
+    I2 i2 = mainComponent.i2();
+    I3 i3 = mainComponent.i3();
+    System.out.println(i1 == mainComponent.i1());
+    System.out.println(i2 == mainComponent.i2());
+    System.out.println(i3 == mainComponent.i3());
+    System.out.println(i1.getName());
+    System.out.println(i2.getName());
+    System.out.println(i3.getName());
+  }
+}
diff --git a/src/test/examplesDagger/basic/MainComponent.java b/src/test/examplesDagger/basic/MainComponent.java
new file mode 100644
index 0000000..0a6e1f6
--- /dev/null
+++ b/src/test/examplesDagger/basic/MainComponent.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2022, 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 basic;
+
+interface MainComponent {
+  I1 i1();
+
+  I2 i2();
+
+  I3 i3();
+}
diff --git a/src/test/examplesDagger/basic/MainComponentUsingBinds.java b/src/test/examplesDagger/basic/MainComponentUsingBinds.java
new file mode 100644
index 0000000..41896b0
--- /dev/null
+++ b/src/test/examplesDagger/basic/MainComponentUsingBinds.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2022, 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 basic;
+
+import dagger.Component;
+import javax.inject.Singleton;
+
+@Component(modules = ModuleUsingBinds.class)
+@Singleton
+interface MainComponentUsingBinds extends MainComponent {}
diff --git a/src/test/examplesDagger/basic/MainComponentUsingProvides.java b/src/test/examplesDagger/basic/MainComponentUsingProvides.java
new file mode 100644
index 0000000..c83fe30
--- /dev/null
+++ b/src/test/examplesDagger/basic/MainComponentUsingProvides.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2022, 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 basic;
+
+import dagger.Component;
+import javax.inject.Singleton;
+
+@Component(modules = ModuleUsingProvides.class)
+@Singleton
+interface MainComponentUsingProvides extends MainComponent {}
diff --git a/src/test/examplesDagger/basic/MainUsingBinds.java b/src/test/examplesDagger/basic/MainUsingBinds.java
new file mode 100644
index 0000000..4470917
--- /dev/null
+++ b/src/test/examplesDagger/basic/MainUsingBinds.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2022, 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 basic;
+
+public class MainUsingBinds extends MainBase {
+  public static void main(String[] args) {
+    new MainUsingBinds().test(DaggerMainComponentUsingBinds.create());
+  }
+}
diff --git a/src/test/examplesDagger/basic/MainUsingProvides.java b/src/test/examplesDagger/basic/MainUsingProvides.java
new file mode 100644
index 0000000..5ebe417
--- /dev/null
+++ b/src/test/examplesDagger/basic/MainUsingProvides.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2022, 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 basic;
+
+public class MainUsingProvides extends MainBase {
+  public static void main(String[] args) {
+    new MainUsingProvides().test(DaggerMainComponentUsingProvides.create());
+  }
+}
diff --git a/src/test/examplesDagger/basic/ModuleUsingBinds.java b/src/test/examplesDagger/basic/ModuleUsingBinds.java
new file mode 100644
index 0000000..6b8df40
--- /dev/null
+++ b/src/test/examplesDagger/basic/ModuleUsingBinds.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2022, 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 basic;
+
+import dagger.Binds;
+import dagger.Module;
+
+@Module
+interface ModuleUsingBinds {
+  @Binds
+  I1 i1(I1Impl1 i1);
+
+  @Binds
+  I2 i2(I2Impl1 i2);
+
+  @Binds
+  I3 i3(I3Impl1 i3);
+}
diff --git a/src/test/examplesDagger/basic/ModuleUsingProvides.java b/src/test/examplesDagger/basic/ModuleUsingProvides.java
new file mode 100644
index 0000000..4c3048b
--- /dev/null
+++ b/src/test/examplesDagger/basic/ModuleUsingProvides.java
@@ -0,0 +1,28 @@
+// Copyright (c) 2022, 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 basic;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+class ModuleUsingProvides {
+  @Provides
+  // @Singleton (added by transformer in some tests)
+  public static I1 i1() {
+    return new I1Impl2();
+  }
+
+  @Provides
+  // @Singleton (added by transformer in some tests)
+  public static I2 i2() {
+    return new I2Impl2();
+  }
+
+  @Provides
+  // @Singleton (added by transformer in some tests)
+  public static I3 i3() {
+    return new I3Impl2();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/JavaCompilerTool.java b/src/test/java/com/android/tools/r8/JavaCompilerTool.java
index c7f7652..1021d65 100644
--- a/src/test/java/com/android/tools/r8/JavaCompilerTool.java
+++ b/src/test/java/com/android/tools/r8/JavaCompilerTool.java
@@ -26,8 +26,11 @@
   private final CfRuntime jdk;
   private final TestState state;
   private final List<Path> sources = new ArrayList<>();
+  private final List<String> classNames = new ArrayList<>();
   private final List<Path> classpath = new ArrayList<>();
   private final List<String> options = new ArrayList<>();
+  private final List<Path> annotationProcessorPath = new ArrayList<>();
+  private final List<String> annotationProcessors = new ArrayList<>();
   private Path output = null;
 
   private JavaCompilerTool(CfRuntime jdk, TestState state) {
@@ -63,6 +66,11 @@
     return this;
   }
 
+  public JavaCompilerTool addClassNames(Collection<String> classNames) {
+    this.classNames.addAll(classNames);
+    return this;
+  }
+
   public JavaCompilerTool addClasspathFiles(Path... files) {
     return addClasspathFiles(Arrays.asList(files));
   }
@@ -72,6 +80,24 @@
     return this;
   }
 
+  public JavaCompilerTool addAnnotationProcessorPathFiles(Path... files) {
+    return addAnnotationProcessorPathFiles(Arrays.asList(files));
+  }
+
+  public JavaCompilerTool addAnnotationProcessorPathFiles(Collection<Path> files) {
+    annotationProcessorPath.addAll(files);
+    return this;
+  }
+
+  public JavaCompilerTool addAnnotationProcessors(String... processors) {
+    return addAnnotationProcessor(Arrays.asList(processors));
+  }
+
+  public JavaCompilerTool addAnnotationProcessor(Collection<String> processors) {
+    annotationProcessors.addAll(processors);
+    return this;
+  }
+
   /** Set the output. Must be to an existing directory or to an non-existing jar file. */
   public JavaCompilerTool setOutputPath(Path file) {
     assert (Files.exists(file) && Files.isDirectory(file))
@@ -103,6 +129,8 @@
     return output;
   }
 
+  // For javac command line options see
+  // https://docs.oracle.com/en/java/javase/17/docs/specs/man/javac.html.
   private ProcessResult compileInternal(Path output) throws IOException {
     Path outdir = Files.isDirectory(output) ? output : state.getNewTempFolder();
     List<String> cmdline = new ArrayList<>();
@@ -115,11 +143,23 @@
               .map(Path::toString)
               .collect(Collectors.joining(isWindows() ? ";" : ":")));
     }
+    if (!annotationProcessorPath.isEmpty()) {
+      cmdline.add("-processorpath");
+      cmdline.add(
+          annotationProcessorPath.stream()
+              .map(Path::toString)
+              .collect(Collectors.joining(isWindows() ? ";" : ":")));
+    }
+    if (!annotationProcessors.isEmpty()) {
+      cmdline.add("-processor");
+      cmdline.add(String.join(",", annotationProcessors));
+    }
     cmdline.add("-d");
     cmdline.add(outdir.toString());
     for (Path source : sources) {
       cmdline.add(source.toString());
     }
+    cmdline.addAll(classNames);
     ProcessBuilder builder = new ProcessBuilder(cmdline);
     ProcessResult javacResult = ToolHelper.runProcess(builder);
     if (FileUtils.isJarFile(output)) {
diff --git a/src/test/java/com/android/tools/r8/dagger/DaggerBasicNotSingletonUsingBindsTest.java b/src/test/java/com/android/tools/r8/dagger/DaggerBasicNotSingletonUsingBindsTest.java
new file mode 100644
index 0000000..c6ca2b1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dagger/DaggerBasicNotSingletonUsingBindsTest.java
@@ -0,0 +1,80 @@
+// Copyright (c) 2022, 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.dagger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.DaggerUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.BeforeClass;
+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 DaggerBasicNotSingletonUsingBindsTest extends DaggerBasicTestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    return buildParameters(getTestParameters().withAllRuntimes().withAllApiLevels().build());
+  }
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    compileWithoutSingleton();
+  }
+
+  public static final String MAIN_CLASS = "basic.MainUsingBinds";
+  public static final List<String> EXPECTED_OUTPUT =
+      ImmutableList.of("false", "false", "false", "I1Impl1", "I2Impl1", "I3Impl1");
+
+  @Test
+  public void testJvm() throws Exception {
+    assumeTrue(parameters.isCfRuntime());
+    testForJvm()
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    testForD8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  private void inspect(CodeInspector inspector) {
+    assertEquals(parameters.isCfRuntime() ? 1 : 2, inspector.allClasses().size());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_CLASS)
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .inspect(this::inspect)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/dagger/DaggerBasicNotSingletonUsingProvidesTest.java b/src/test/java/com/android/tools/r8/dagger/DaggerBasicNotSingletonUsingProvidesTest.java
new file mode 100644
index 0000000..149b665
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dagger/DaggerBasicNotSingletonUsingProvidesTest.java
@@ -0,0 +1,80 @@
+// Copyright (c) 2022, 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.dagger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.DaggerUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.BeforeClass;
+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 DaggerBasicNotSingletonUsingProvidesTest extends DaggerBasicTestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    return buildParameters(getTestParameters().withAllRuntimes().withAllApiLevels().build());
+  }
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    compileWithoutSingleton();
+  }
+
+  public static final String MAIN_CLASS = "basic.MainUsingProvides";
+  public static final List<String> EXPECTED_OUTPUT =
+      ImmutableList.of("false", "false", "false", "I1Impl2", "I2Impl2", "I3Impl2");
+
+  @Test
+  public void testJvm() throws Exception {
+    assumeTrue(parameters.isCfRuntime());
+    testForJvm()
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    testForD8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  private void inspect(CodeInspector inspector) {
+    assertEquals(1, inspector.allClasses().size());
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_CLASS)
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .inspect(this::inspect)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/dagger/DaggerBasicSingletonUsingBindsTest.java b/src/test/java/com/android/tools/r8/dagger/DaggerBasicSingletonUsingBindsTest.java
new file mode 100644
index 0000000..50e0493
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dagger/DaggerBasicSingletonUsingBindsTest.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2022, 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.dagger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.DaggerUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.BeforeClass;
+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 DaggerBasicSingletonUsingBindsTest extends DaggerBasicTestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    return buildParameters(getTestParameters().withAllRuntimes().withAllApiLevels().build());
+  }
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    DaggerBasicTestBase.compileWithSingleton();
+  }
+
+  public static final String MAIN_CLASS = "basic.MainUsingBinds";
+  public static final List<String> EXPECTED_OUTPUT =
+      ImmutableList.of("true", "true", "true", "I1Impl1", "I2Impl1", "I3Impl1");
+
+  @Test
+  public void testJvm() throws Exception {
+    assumeTrue(parameters.isCfRuntime());
+    testForJvm()
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    testForD8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  private void inspect(CodeInspector inspector) {
+    assertEquals(
+        ImmutableSet.of(
+            "basic.I1Impl1",
+            "basic.I2Impl1",
+            "basic.I3Impl1",
+            "basic.MainUsingBinds",
+            "basic.DaggerMainComponentUsingBinds",
+            "dagger.internal.DoubleCheck",
+            "javax.inject.Provider"),
+        inspector.allClasses().stream()
+            .map(FoundClassSubject::getOriginalName)
+            .filter(name -> !name.contains("_Factory"))
+            .collect(Collectors.toSet()));
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_CLASS)
+        .addHorizontallyMergedClassesInspector(
+            inspector -> {
+              inspector
+                  .assertIsCompleteMergeGroup(
+                      "basic.I1Impl1_Factory", "basic.I2Impl1_Factory", "basic.I3Impl1_Factory")
+                  .assertIsCompleteMergeGroup(
+                      "basic.I1Impl1_Factory$InstanceHolder",
+                      "basic.I2Impl1_Factory$InstanceHolder",
+                      "basic.I3Impl1_Factory$InstanceHolder")
+                  .assertNoOtherClassesMerged();
+            })
+        .addVerticallyMergedClassesInspector(
+            inspector -> inspector.assertMergedIntoSubtype("basic.I1", "basic.I2", "basic.I3"))
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .inspect(this::inspect)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/dagger/DaggerBasicSingletonUsingProvidesTest.java b/src/test/java/com/android/tools/r8/dagger/DaggerBasicSingletonUsingProvidesTest.java
new file mode 100644
index 0000000..dfe6a1a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dagger/DaggerBasicSingletonUsingProvidesTest.java
@@ -0,0 +1,112 @@
+// Copyright (c) 2022, 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.dagger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.DaggerUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.BeforeClass;
+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 DaggerBasicSingletonUsingProvidesTest extends DaggerBasicTestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static List<Object[]> data() {
+    return buildParameters(getTestParameters().withAllRuntimes().withAllApiLevels().build());
+  }
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    DaggerBasicTestBase.compileWithSingleton();
+  }
+
+  public static final String MAIN_CLASS = "basic.MainUsingProvides";
+  public static final List<String> EXPECTED_OUTPUT =
+      ImmutableList.of("true", "true", "true", "I1Impl2", "I2Impl2", "I3Impl2");
+
+  private void inspect(CodeInspector inspector) {
+    assertEquals(
+        ImmutableSet.of(
+            "basic.I1Impl2",
+            "basic.I2Impl2",
+            "basic.I3Impl2",
+            "basic.MainUsingProvides",
+            "basic.DaggerMainComponentUsingProvides",
+            "dagger.internal.DoubleCheck",
+            "javax.inject.Provider"),
+        inspector.allClasses().stream()
+            .map(FoundClassSubject::getOriginalName)
+            .filter(name -> !name.contains("Factory"))
+            .collect(Collectors.toSet()));
+  }
+
+  @Test
+  public void testJvm() throws Exception {
+    assumeTrue(parameters.isCfRuntime());
+    testForJvm()
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue(parameters.isDexRuntime());
+    testForD8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramNotDependingOnDagger)
+        .addProgramFiles(DaggerBasicTestBase.compiledProgramDependingOnDagger)
+        .addProgramFiles(DaggerUtils.getDaggerRuntime())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(MAIN_CLASS)
+        .addHorizontallyMergedClassesInspector(
+            inspector -> {
+              inspector
+                  .assertIsCompleteMergeGroup(
+                      "basic.ModuleUsingProvides_I1Factory",
+                      "basic.ModuleUsingProvides_I2Factory",
+                      "basic.ModuleUsingProvides_I3Factory")
+                  .assertIsCompleteMergeGroup(
+                      "basic.ModuleUsingProvides_I1Factory$InstanceHolder",
+                      "basic.ModuleUsingProvides_I2Factory$InstanceHolder",
+                      "basic.ModuleUsingProvides_I3Factory$InstanceHolder")
+                  .assertIsCompleteMergeGroup(
+                      "basic.ModuleUsingProvides", "basic.DaggerMainComponentUsingProvides$1")
+                  .assertNoOtherClassesMerged();
+            })
+        .addVerticallyMergedClassesInspector(
+            inspector -> inspector.assertMergedIntoSubtype("basic.I1", "basic.I2", "basic.I3"))
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .inspect(this::inspect)
+        .assertSuccessWithOutputLines(EXPECTED_OUTPUT);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/dagger/DaggerBasicTestBase.java b/src/test/java/com/android/tools/r8/dagger/DaggerBasicTestBase.java
new file mode 100644
index 0000000..3f56ab1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/dagger/DaggerBasicTestBase.java
@@ -0,0 +1,141 @@
+// Copyright (c) 2022, 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.dagger;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.transformers.ClassTransformer;
+import com.android.tools.r8.transformers.MethodTransformer;
+import com.android.tools.r8.utils.DaggerUtils;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.ZipUtils;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class DaggerBasicTestBase extends TestBase {
+
+  public static Path compiledProgramNotDependingOnDagger;
+  public static Path compiledProgramDependingOnDagger;
+  public static Path daggerGeneratedSourceFiles;
+
+  private static void compile(
+      List<Path> sourceNotDependingOnDagger,
+      List<Path> sourceDependingOnDagger,
+      BiFunction<String, byte[], byte[]> transformer)
+      throws Exception {
+    compiledProgramNotDependingOnDagger =
+        DaggerUtils.compileWithoutAnnotationProcessing(sourceNotDependingOnDagger);
+    // Use transformer on code not depending on Dagger.
+    if (transformer != null) {
+      compiledProgramNotDependingOnDagger =
+          ZipUtils.map(
+              compiledProgramNotDependingOnDagger,
+              getStaticTemp().newFolder().toPath().resolve("transformed.jar"),
+              (entry, bytes) ->
+                  FileUtils.isClassFile(entry.getName())
+                      ? transformer.apply(
+                          entry
+                              .getName()
+                              .substring(
+                                  0, entry.getName().length() - FileUtils.CLASS_EXTENSION.length()),
+                          bytes)
+                      : bytes);
+    }
+    // Compile with Dagger annotation processor. The part of the program not relying on dagger
+    // generated types are passed as class files (potentially after transformation) and on command
+    // line for being included in annotation processing.
+    compiledProgramDependingOnDagger =
+        DaggerUtils.compileWithAnnotationProcessing(
+            sourceDependingOnDagger, ImmutableList.of(compiledProgramNotDependingOnDagger));
+    daggerGeneratedSourceFiles =
+        ZipUtils.filter(
+            compiledProgramDependingOnDagger,
+            getStaticTemp().newFolder().toPath().resolve("source.jar"),
+            entry -> entry.getName().endsWith(".java"));
+    // Check the generated Dagger source files.
+    Set<String> generatedFiles = new HashSet<>();
+    ZipUtils.iter(
+        DaggerBasicTestBase.daggerGeneratedSourceFiles,
+        (entry, unused) -> generatedFiles.add(entry.getName()));
+    assertEquals(
+        ImmutableSet.of(
+            "basic/I1Impl1_Factory.java",
+            "basic/I2Impl1_Factory.java",
+            "basic/I3Impl1_Factory.java",
+            "basic/ModuleUsingProvides_I1Factory.java",
+            "basic/ModuleUsingProvides_I2Factory.java",
+            "basic/ModuleUsingProvides_I3Factory.java",
+            "basic/ModuleUsingProvides_Proxy.java",
+            "basic/DaggerMainComponentUsingBinds.java",
+            "basic/DaggerMainComponentUsingProvides.java"),
+        generatedFiles);
+  }
+
+  private static boolean sourceFileReferingDaggerGeneratedClasses(Path file) {
+    return file.getFileName().toString().startsWith("Main");
+  }
+
+  static void compileWithSingleton() throws Exception {
+    compile(
+        javaSourceFiles("basic", path -> !sourceFileReferingDaggerGeneratedClasses(path)),
+        javaSourceFiles("basic", DaggerBasicTestBase::sourceFileReferingDaggerGeneratedClasses),
+        DaggerBasicTestBase::transformAddSingleton);
+  }
+
+  static void compileWithoutSingleton() throws Exception {
+    compile(
+        javaSourceFiles("basic", path -> !sourceFileReferingDaggerGeneratedClasses(path)),
+        javaSourceFiles("basic", DaggerBasicTestBase::sourceFileReferingDaggerGeneratedClasses),
+        null);
+  }
+
+  private static byte[] transformAddSingleton(String binaryName, byte[] bytes) {
+    // Add @Singleton to the constructors used with @Bind.
+    if (binaryName.endsWith("Impl1")) {
+      return transformer(bytes, Reference.classFromBinaryName(binaryName))
+          .addClassTransformer(
+              new ClassTransformer() {
+                @Override
+                public void visitEnd() {
+                  super.visitAnnotation("Ljavax/inject/Singleton;", true);
+                }
+              })
+          .transform();
+    }
+    // Add @Singleton to the methods annotated with @Provides.
+    if (binaryName.endsWith("ModuleUsingProvides")) {
+      return transformer(bytes, Reference.classFromBinaryName(binaryName))
+          .addMethodTransformer(
+              new MethodTransformer() {
+                @Override
+                public void visitEnd() {
+                  super.visitAnnotation("Ljavax/inject/Singleton;", true);
+                }
+              })
+          .transform();
+    }
+    return bytes;
+  }
+
+  public static List<Path> javaSourceFiles(String testDir, Predicate<Path> filter)
+      throws Exception {
+    try (Stream<Path> walk =
+        Files.walk(Paths.get(ToolHelper.TESTS_DIR, "examplesDagger", testDir))) {
+      return walk.filter(filter).filter(FileUtils::isJavaFile).collect(Collectors.toList());
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/DaggerUtils.java b/src/test/java/com/android/tools/r8/utils/DaggerUtils.java
new file mode 100644
index 0000000..24eabb5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/DaggerUtils.java
@@ -0,0 +1,111 @@
+// Copyright (c) 2022, 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.utils;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestRuntime;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteStreams;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class DaggerUtils {
+
+  private static final Path DAGGER_ROOT = Paths.get("third_party", "dagger", "2.41");
+  private static final List<Path> DAGGER_COMPILER =
+      ImmutableList.of(
+              "annotations-13.0.jar",
+              "checker-compat-qual-2.5.5.jar",
+              "checker-qual-3.12.0.jar",
+              "dagger-2.41.jar",
+              "dagger-compiler-2.41.jar",
+              "dagger-producers-2.41.jar",
+              "dagger-spi-2.41.jar",
+              "error_prone_annotations-2.7.1.jar",
+              "failureaccess-1.0.1.jar",
+              "google-java-format-1.5.jar",
+              "guava-31.0.1-jre.jar",
+              "incap-0.2.jar",
+              "j2objc-annotations-1.3.jar",
+              "javac-shaded-9-dev-r4023-3.jar",
+              "javapoet-1.13.0.jar",
+              "javax.inject-1.jar",
+              "jsr305-3.0.2.jar",
+              "kotlin-stdlib-1.5.32.jar",
+              "kotlin-stdlib-common-1.5.32.jar",
+              "kotlin-stdlib-jdk7-1.5.32.jar",
+              "kotlin-stdlib-jdk8-1.5.32.jar",
+              "kotlinx-metadata-jvm-0.3.0.jar",
+              "symbol-processing-api-1.5.30-1.0.0.jar")
+          .stream()
+          .map(DAGGER_ROOT::resolve)
+          .collect(ImmutableList.toImmutableList());
+  private static final List<Path> DAGGER_RUNTIME =
+      ImmutableList.of("dagger-2.41.jar", "javax.inject-1.jar").stream()
+          .map(DAGGER_ROOT::resolve)
+          .collect(ImmutableList.toImmutableList());
+
+  public static List<Path> getDaggerRuntime() {
+    return DAGGER_RUNTIME;
+  }
+
+  public static Path compileWithAnnotationProcessing(
+      Collection<Path> sourceFiles, Collection<Path> classFiles) throws Exception {
+    // Class files are provided in JAR files. Extract all the class names to pass to javac for
+    // annotation processing.
+    List<String> classNames = new ArrayList<>();
+    for (Path path : classFiles) {
+      ZipUtils.iter(
+          path,
+          (entry, inputStream) -> {
+            String entryString = entry.toString();
+            if (FileUtils.isClassFile(entryString)) {
+              byte[] bytes = ByteStreams.toByteArray(inputStream);
+              classNames.add(TestBase.extractClassName(bytes));
+            }
+          });
+    }
+    return TestBase.javac(TestRuntime.getCheckedInJdk8(), TestBase.getStaticTemp())
+        .addSourceFiles(sourceFiles)
+        .addClassNames(classNames)
+        .addClasspathFiles(classFiles)
+        .addClasspathFiles(getDaggerRuntime())
+        .addAnnotationProcessorPathFiles(DAGGER_COMPILER)
+        .addAnnotationProcessors("dagger.internal.codegen.ComponentProcessor")
+        .compile();
+  }
+
+  public static Path compileWithAnnotationProcessing(Collection<Path> files) throws Exception {
+    // Split the files passed into source files and class files. Class files are expected to be in
+    // JARs.
+    List<Path> sourceFiles =
+        files.stream().filter(FileUtils::isJavaFile).collect(Collectors.toList());
+    List<Path> classFiles =
+        files.stream().filter(FileUtils::isJarFile).collect(Collectors.toList());
+    assertEquals(files.size(), sourceFiles.size() + classFiles.size());
+    return compileWithAnnotationProcessing(sourceFiles, classFiles);
+  }
+
+  public static Path compileWithoutAnnotationProcessing(Collection<Path> files) throws Exception {
+    return TestBase.javac(TestRuntime.getCheckedInJdk8(), TestBase.getStaticTemp())
+        .addSourceFiles(files)
+        .addClasspathFiles(getDaggerRuntime())
+        .compile();
+  }
+
+  public static Path compileWithoutAnnotationProcessing(Path... files) throws Exception {
+    return compileWithoutAnnotationProcessing(Arrays.asList(files));
+  }
+
+  public static Path compileWithAnnotationProcessing(Path... files) throws Exception {
+    return compileWithAnnotationProcessing(Arrays.asList(files));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java
index 05031f2..d1f04cb 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/VerticallyMergedClassesInspector.java
@@ -9,6 +9,8 @@
 
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
 
 public class VerticallyMergedClassesInspector {
 
@@ -33,6 +35,20 @@
     return this;
   }
 
+  public VerticallyMergedClassesInspector assertMergedIntoSubtype(ClassReference classReference) {
+    assertTrue(
+        verticallyMergedClasses.hasBeenMergedIntoSubtype(
+            toDexType(classReference, dexItemFactory)));
+    return this;
+  }
+
+  public VerticallyMergedClassesInspector assertMergedIntoSubtype(String... typeNames) {
+    for (String typeName : typeNames) {
+      assertMergedIntoSubtype(Reference.classFromTypeName(typeName));
+    }
+    return this;
+  }
+
   public VerticallyMergedClassesInspector assertNoClassesMerged() {
     assertTrue(verticallyMergedClasses.isEmpty());
     return this;