diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticallyMergedClasses.java b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticallyMergedClasses.java
index d6f3e64..e2709cf 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/VerticallyMergedClasses.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/VerticallyMergedClasses.java
@@ -47,6 +47,10 @@
     return mergedClasses.getForwardMap();
   }
 
+  public Set<DexType> getSources() {
+    return mergedClasses.keySet();
+  }
+
   public Collection<DexType> getSourcesFor(DexType type) {
     return mergedClasses.getKeys(type);
   }
diff --git a/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerInvokeVirtualToInterfaceTest.java b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerInvokeVirtualToInterfaceTest.java
new file mode 100644
index 0000000..e6e9fba
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/classmerging/vertical/VerticalClassMergerInvokeVirtualToInterfaceTest.java
@@ -0,0 +1,93 @@
+// Copyright (c) 2024, 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.classmerging.vertical;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoParameterTypeStrengthening;
+import com.android.tools.r8.NoUnusedInterfaceRemoval;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+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 VerticalClassMergerInvokeVirtualToInterfaceTest extends TestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(Main.class)
+        .addVerticallyMergedClassesInspector(
+            inspector -> inspector.assertMergedIntoSubtype(J.class).assertNoOtherClassesMerged())
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .enableNoParameterTypeStrengtheningAnnotations()
+        .enableNoUnusedInterfaceRemovalAnnotations()
+        .enableNoVerticalClassMergingAnnotations()
+        .setMinApi(parameters)
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("Hello, world!", "Hello, world!");
+  }
+
+  static class Main {
+
+    public static void main(String[] args) {
+      callOnI(new B());
+      callOnJ(new B());
+    }
+
+    @NeverInline
+    @NoParameterTypeStrengthening
+    static void callOnI(I i) {
+      i.m();
+    }
+
+    @NeverInline
+    @NoParameterTypeStrengthening
+    static void callOnJ(J j) {
+      j.m();
+    }
+  }
+
+  @NoUnusedInterfaceRemoval
+  @NoVerticalClassMerging
+  interface I {
+
+    void m();
+  }
+
+  @NoUnusedInterfaceRemoval
+  interface J {
+
+    void m();
+  }
+
+  @NoVerticalClassMerging
+  abstract static class A implements I, J {}
+
+  @NeverClassInline
+  static class B extends A {
+
+    @NeverInline
+    public void m() {
+      System.out.println("Hello, world!");
+    }
+  }
+}
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 5b8f002..bf038dd 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
@@ -8,15 +8,20 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.verticalclassmerging.VerticallyMergedClasses;
+import java.util.HashSet;
+import java.util.Set;
 
 public class VerticallyMergedClassesInspector {
 
   private final DexItemFactory dexItemFactory;
   private final VerticallyMergedClasses verticallyMergedClasses;
 
+  private final Set<ClassReference> seen = new HashSet<>();
+
   public VerticallyMergedClassesInspector(
       DexItemFactory dexItemFactory, VerticallyMergedClasses verticallyMergedClasses) {
     this.dexItemFactory = dexItemFactory;
@@ -24,8 +29,7 @@
   }
 
   public VerticallyMergedClassesInspector assertMergedIntoSubtype(Class<?> clazz) {
-    assertTrue(verticallyMergedClasses.hasBeenMergedIntoSubtype(toDexType(clazz, dexItemFactory)));
-    return this;
+    return assertMergedIntoSubtype(Reference.classFromClass(clazz));
   }
 
   public VerticallyMergedClassesInspector assertMergedIntoSubtype(Class<?>... classes) {
@@ -39,6 +43,7 @@
     assertTrue(
         verticallyMergedClasses.hasBeenMergedIntoSubtype(
             toDexType(classReference, dexItemFactory)));
+    seen.add(classReference);
     return this;
   }
 
@@ -53,4 +58,11 @@
     assertTrue(verticallyMergedClasses.isEmpty());
     return this;
   }
+
+  public VerticallyMergedClassesInspector assertNoOtherClassesMerged() {
+    for (DexType source : verticallyMergedClasses.getSources()) {
+      assertTrue(source.getTypeName(), seen.contains(source.asClassReference()));
+    }
+    return this;
+  }
 }