diff --git a/src/test/java/com/android/tools/r8/D8TestBuilder.java b/src/test/java/com/android/tools/r8/D8TestBuilder.java
index c8c21fa..de0565f 100644
--- a/src/test/java/com/android/tools/r8/D8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/D8TestBuilder.java
@@ -9,16 +9,12 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.profile.art.ArtProfileConsumer;
 import com.android.tools.r8.profile.art.ArtProfileProvider;
-import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.startup.StartupProfileProvider;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import java.nio.file.Path;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
@@ -36,7 +32,6 @@
 
   private StringBuilder proguardMapOutputBuilder = null;
   private boolean enableMissingLibraryApiModeling = true;
-  private List<ExternalArtProfile> residualArtProfiles = new ArrayList<>();
 
   @Override
   public boolean isD8TestBuilder() {
@@ -139,16 +134,6 @@
     return self();
   }
 
-  public D8TestBuilder addArtProfileForRewriting(ArtProfileProvider artProfileProvider) {
-    return addArtProfileForRewriting(
-        artProfileProvider,
-        ArtProfileTestingUtils.createResidualArtProfileConsumer(residualArtProfiles::add));
-  }
-
-  public D8TestBuilder addArtProfileForRewriting(ExternalArtProfile artProfile) {
-    return addArtProfileForRewriting(ArtProfileTestingUtils.createArtProfileProvider(artProfile));
-  }
-
   public D8TestBuilder addArtProfileForRewriting(
       ArtProfileProvider artProfileProvider, ArtProfileConsumer residualArtProfileConsumer) {
     builder.addArtProfileForRewriting(artProfileProvider, residualArtProfileConsumer);
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
index 34f8a0b..a844c1f 100644
--- a/src/test/java/com/android/tools/r8/R8TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -17,8 +17,6 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.profile.art.ArtProfileConsumer;
 import com.android.tools.r8.profile.art.ArtProfileProvider;
-import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.shaking.CheckEnumUnboxedRule;
 import com.android.tools.r8.shaking.CollectingGraphConsumer;
 import com.android.tools.r8.shaking.KeepUnusedReturnValueRule;
@@ -70,7 +68,6 @@
   private boolean allowUnusedProguardConfigurationRules = false;
   private boolean enableMissingLibraryApiModeling = true;
   private CollectingGraphConsumer graphConsumer = null;
-  private List<ExternalArtProfile> residualArtProfiles = new ArrayList<>();
   private List<String> keepRules = new ArrayList<>();
   private List<Path> mainDexRulesFiles = new ArrayList<>();
   private List<String> applyMappingMaps = new ArrayList<>();
@@ -161,8 +158,7 @@
             createDefaultProguardMapConsumer ? proguardMapBuilder.toString() : null,
             graphConsumer,
             getMinApiLevel(),
-            features,
-            residualArtProfiles);
+            features);
     switch (allowedDiagnosticMessages) {
       case ALL:
         compileResult.getDiagnosticMessages().assertAllDiagnosticsMatch(new IsAnything<>());
@@ -786,16 +782,6 @@
     return self();
   }
 
-  public T addArtProfileForRewriting(ArtProfileProvider artProfileProvider) {
-    return addArtProfileForRewriting(
-        artProfileProvider,
-        ArtProfileTestingUtils.createResidualArtProfileConsumer(residualArtProfiles::add));
-  }
-
-  public T addArtProfileForRewriting(ExternalArtProfile artProfile) {
-    return addArtProfileForRewriting(ArtProfileTestingUtils.createArtProfileProvider(artProfile));
-  }
-
   public T addArtProfileForRewriting(
       ArtProfileProvider artProfileProvider, ArtProfileConsumer residualArtProfileConsumer) {
     builder.addArtProfileForRewriting(artProfileProvider, residualArtProfileConsumer);
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index b3b6e31..688ab43 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -9,14 +9,11 @@
 
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.dexsplitter.SplitterTestBase.SplitRunner;
-import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
 import com.android.tools.r8.shaking.CollectingGraphConsumer;
 import com.android.tools.r8.shaking.ProguardConfiguration;
 import com.android.tools.r8.shaking.ProguardConfigurationRule;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.FileUtils;
-import com.android.tools.r8.utils.ThrowingBiConsumer;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -25,7 +22,6 @@
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Set;
-import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 
 public class R8TestCompileResult extends TestCompileResult<R8TestCompileResult, R8TestRunResult> {
@@ -35,7 +31,6 @@
   private final String proguardMap;
   private final CollectingGraphConsumer graphConsumer;
   private final List<Path> features;
-  private final List<ExternalArtProfile> residualArtProfiles;
 
   R8TestCompileResult(
       TestState state,
@@ -47,15 +42,13 @@
       String proguardMap,
       CollectingGraphConsumer graphConsumer,
       int minApiLevel,
-      List<Path> features,
-      List<ExternalArtProfile> residualArtProfiles) {
+      List<Path> features) {
     super(state, app, minApiLevel, outputMode, libraryDesugaringTestConfiguration);
     this.proguardConfiguration = proguardConfiguration;
     this.syntheticProguardRules = syntheticProguardRules;
     this.proguardMap = proguardMap;
     this.graphConsumer = graphConsumer;
     this.features = features;
-    this.residualArtProfiles = residualArtProfiles;
   }
 
   @Override
@@ -131,19 +124,6 @@
     return self();
   }
 
-  public <E extends Throwable> R8TestCompileResult inspectResidualArtProfile(
-      ThrowingConsumer<ArtProfileInspector, E> consumer) throws E, IOException, ExecutionException {
-    return inspectResidualArtProfile(
-        (rewrittenArtProfile, inspector) -> consumer.accept(rewrittenArtProfile));
-  }
-
-  public <E extends Throwable> R8TestCompileResult inspectResidualArtProfile(
-      ThrowingBiConsumer<ArtProfileInspector, CodeInspector, E> consumer) throws E, IOException {
-    assertEquals(1, residualArtProfiles.size());
-    consumer.accept(new ArtProfileInspector(residualArtProfiles.iterator().next()), inspector());
-    return self();
-  }
-
   public GraphInspector graphInspector() throws IOException {
     assert graphConsumer != null;
     return new GraphInspector(graphConsumer, inspector());
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
index ed81c32..4144aaa 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestBuilder.java
@@ -27,8 +27,6 @@
 import com.android.tools.r8.profile.art.ArtProfileConsumer;
 import com.android.tools.r8.profile.art.ArtProfileForRewriting;
 import com.android.tools.r8.profile.art.ArtProfileProvider;
-import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.tracereferences.TraceReferences;
 import com.android.tools.r8.utils.ConsumerUtils;
 import com.android.tools.r8.utils.FileUtils;
@@ -60,7 +58,6 @@
 
   private CustomLibrarySpecification customLibrarySpecification = null;
   private TestingKeepRuleConsumer keepRuleConsumer = null;
-  private List<ExternalArtProfile> l8ResidualArtProfiles = new ArrayList<>();
 
   public DesugaredLibraryTestBuilder(
       T test,
@@ -381,8 +378,7 @@
         libraryDesugaringSpecification,
         compilationSpecification,
         customLibCompile,
-        l8Compile,
-        l8ResidualArtProfiles);
+        l8Compile);
   }
 
   private D8TestCompileResult compileCustomLib() throws CompilationFailedException {
@@ -505,18 +501,7 @@
     return this;
   }
 
-  public DesugaredLibraryTestBuilder<T> addL8ArtProfileForRewriting(
-      ArtProfileProvider artProfileProvider) {
-    return addL8ArtProfileForRewriting(
-        artProfileProvider,
-        ArtProfileTestingUtils.createResidualArtProfileConsumer(l8ResidualArtProfiles::add));
-  }
-
-  public DesugaredLibraryTestBuilder<T> addL8ArtProfileForRewriting(ExternalArtProfile artProfile) {
-    return addL8ArtProfileForRewriting(ArtProfileTestingUtils.createArtProfileProvider(artProfile));
-  }
-
-  public DesugaredLibraryTestBuilder<T> addL8ArtProfileForRewriting(
+  public DesugaredLibraryTestBuilder<?> addL8ArtProfileForRewriting(
       ArtProfileProvider artProfileProvider, ArtProfileConsumer residualArtProfileConsumer) {
     l8ArtProfilesForRewriting.add(
         new ArtProfileForRewriting(artProfileProvider, residualArtProfileConsumer));
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
index d49f2ef..3172876 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/test/DesugaredLibraryTestCompileResult.java
@@ -4,8 +4,6 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary.test;
 
-import static org.junit.Assert.assertEquals;
-
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.D8TestCompileResult;
 import com.android.tools.r8.L8TestCompileResult;
@@ -15,9 +13,6 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestRuntime;
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
-import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
-import com.android.tools.r8.utils.ThrowingBiConsumer;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
@@ -35,7 +30,6 @@
   private final CompilationSpecification compilationSpecification;
   private final D8TestCompileResult customLibCompile;
   private final L8TestCompileResult l8Compile;
-  private final List<ExternalArtProfile> l8ResidualArtProfiles;
   // In case of Cf2Cf desugaring the run on dex, the compileResult is the Cf desugaring result
   // while the runnableCompiledResult is the dexed compiledResult used to run on dex.
   private final TestCompileResult<?, ? extends SingleTestRunResult<?>> runnableCompiledResult;
@@ -47,8 +41,7 @@
       LibraryDesugaringSpecification libraryDesugaringSpecification,
       CompilationSpecification compilationSpecification,
       D8TestCompileResult customLibCompile,
-      L8TestCompileResult l8Compile,
-      List<ExternalArtProfile> l8ResidualArtProfiles)
+      L8TestCompileResult l8Compile)
       throws CompilationFailedException, IOException {
     this.test = test;
     this.compileResult = compileResult;
@@ -57,7 +50,6 @@
     this.compilationSpecification = compilationSpecification;
     this.customLibCompile = customLibCompile;
     this.l8Compile = l8Compile;
-    this.l8ResidualArtProfiles = l8ResidualArtProfiles;
     this.runnableCompiledResult = computeRunnableCompiledResult();
   }
 
@@ -74,20 +66,6 @@
     return this;
   }
 
-  public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectL8ResidualArtProfile(
-      ThrowingConsumer<ArtProfileInspector, E> consumer) throws E, IOException, ExecutionException {
-    return inspectL8ResidualArtProfile(
-        (rewrittenArtProfile, inspector) -> consumer.accept(rewrittenArtProfile));
-  }
-
-  public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspectL8ResidualArtProfile(
-      ThrowingBiConsumer<ArtProfileInspector, CodeInspector, E> consumer) throws E, IOException {
-    assertEquals(1, l8ResidualArtProfiles.size());
-    consumer.accept(
-        new ArtProfileInspector(l8ResidualArtProfiles.iterator().next()), l8Inspector());
-    return this;
-  }
-
   public <E extends Throwable> DesugaredLibraryTestCompileResult<T> inspect(
       ThrowingConsumer<CodeInspector, E> consumer) throws IOException, E {
     compileResult.inspect(consumer);
diff --git a/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
index e192b41..922cae7 100644
--- a/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/ArtProfileCollisionAfterClassMergingRewritingTest.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
@@ -14,11 +15,12 @@
 import com.android.tools.r8.profile.art.model.ExternalArtProfile;
 import com.android.tools.r8.profile.art.model.ExternalArtProfileClassRule;
 import com.android.tools.r8.profile.art.model.ExternalArtProfileMethodRule;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
+import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -54,17 +56,21 @@
 
   @Test
   public void test() throws Exception {
+    Box<ExternalArtProfile> residualArtProfile = new Box<>();
     testForR8(Backend.DEX)
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
         .addHorizontallyMergedClassesInspector(
             inspector ->
                 inspector.assertMergedInto(Foo.class, Bar.class).assertNoOtherClassesMerged())
-        .addArtProfileForRewriting(getArtProfile())
+        .apply(
+            testBuilder ->
+                ArtProfileTestingUtils.addArtProfileForRewriting(
+                    getArtProfile(), residualArtProfile::set, testBuilder))
         .enableInliningAnnotations()
         .setMinApi(AndroidApiLevel.LATEST)
         .compile()
-        .inspectResidualArtProfile(this::inspect);
+        .inspect(inspector -> inspect(inspector, residualArtProfile.get()));
   }
 
   public ExternalArtProfile getArtProfile() {
@@ -105,8 +111,8 @@
         .build();
   }
 
-  private void inspect(ArtProfileInspector profileInspector, CodeInspector inspector) {
-    profileInspector.assertEqualTo(getExpectedResidualArtProfile(inspector));
+  private void inspect(CodeInspector inspector, ExternalArtProfile residualArtProfile) {
+    assertEquals(getExpectedResidualArtProfile(inspector), residualArtProfile);
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
index c68b02f..c5fb462 100644
--- a/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/ArtProfileRewritingTest.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
@@ -14,11 +15,12 @@
 import com.android.tools.r8.profile.art.model.ExternalArtProfile;
 import com.android.tools.r8.profile.art.model.ExternalArtProfileClassRule;
 import com.android.tools.r8.profile.art.model.ExternalArtProfileMethodRule;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
+import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -51,14 +53,18 @@
 
   @Test
   public void test() throws Exception {
+    Box<ExternalArtProfile> residualArtProfile = new Box<>();
     testForR8(Backend.DEX)
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
-        .addArtProfileForRewriting(getArtProfile())
+        .apply(
+            testBuilder ->
+                ArtProfileTestingUtils.addArtProfileForRewriting(
+                    getArtProfile(), residualArtProfile::set, testBuilder))
         .enableInliningAnnotations()
         .setMinApi(AndroidApiLevel.LATEST)
         .compile()
-        .inspectResidualArtProfile(this::inspect);
+        .inspect(inspector -> inspect(inspector, residualArtProfile.get()));
   }
 
   private ExternalArtProfile getArtProfile() {
@@ -103,8 +109,8 @@
         .build();
   }
 
-  private void inspect(ArtProfileInspector profileInspector, CodeInspector inspector) {
-    profileInspector.assertEqualTo(getExpectedResidualArtProfile(inspector));
+  private void inspect(CodeInspector inspector, ExternalArtProfile residualArtProfile) {
+    assertEquals(getExpectedResidualArtProfile(inspector), residualArtProfile);
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
index 1a4bfda..52e0beb 100644
--- a/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/DesugaredLibraryArtProfileRewritingTest.java
@@ -18,9 +18,10 @@
 import com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification;
 import com.android.tools.r8.profile.art.model.ExternalArtProfile;
 import com.android.tools.r8.profile.art.model.ExternalArtProfileMethodRule;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
+import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -58,12 +59,16 @@
   @Test
   public void test() throws Throwable {
     Assume.assumeTrue(libraryDesugaringSpecification.hasEmulatedInterfaceDesugaring(parameters));
+    Box<ExternalArtProfile> residualArtProfile = new Box<>();
     testForDesugaredLibrary(parameters, libraryDesugaringSpecification, compilationSpecification)
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
-        .addL8ArtProfileForRewriting(getArtProfile())
+        .apply(
+            testBuilder ->
+                ArtProfileTestingUtils.addArtProfileForRewriting(
+                    getArtProfile(), residualArtProfile::set, testBuilder))
         .compile()
-        .inspectL8ResidualArtProfile(this::inspect)
+        .inspectL8(inspector -> inspect(inspector, residualArtProfile.get()))
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("0");
   }
@@ -95,7 +100,7 @@
         .build();
   }
 
-  private void inspect(ArtProfileInspector profileInspector, CodeInspector inspector) {
+  private void inspect(CodeInspector inspector, ExternalArtProfile residualArtProfile) {
     ClassSubject consumerClassSubject =
         inspector.clazz(
             libraryDesugaringSpecification.functionPrefix(parameters) + ".util.function.Consumer");
@@ -112,7 +117,7 @@
                 && libraryDesugaringSpecification == LibraryDesugaringSpecification.JDK8));
     assertEquals(consumerClassSubject.asTypeSubject(), forEachMethodSubject.getParameter(0));
 
-    profileInspector.assertEqualTo(getExpectedResidualArtProfile(forEachMethodSubject));
+    assertEquals(getExpectedResidualArtProfile(forEachMethodSubject), residualArtProfile);
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/profile/art/NoSuchClassAndMethodProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/NoSuchClassAndMethodProfileRewritingTest.java
index 7b598a1..ea4933c 100644
--- a/src/test/java/com/android/tools/r8/profile/art/NoSuchClassAndMethodProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/NoSuchClassAndMethodProfileRewritingTest.java
@@ -4,13 +4,14 @@
 
 package com.android.tools.r8.profile.art;
 
+import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
+import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import org.junit.Test;
@@ -35,11 +36,12 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
-        .addArtProfileForRewriting(getArtProfile())
+        .apply(
+            ArtProfileTestingUtils.addArtProfileForRewriting(
+                getArtProfile(), this::inspectResidualArtProfile))
         .setMinApi(parameters.getApiLevel())
         // TODO(b/266178791): Emit a warning for each discarded item.
         .compileWithExpectedDiagnostics(TestDiagnosticMessages::assertNoMessages)
-        .inspectResidualArtProfile(this::inspectResidualArtProfile)
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello, world!");
   }
@@ -52,10 +54,10 @@
         .build();
   }
 
-  private void inspectResidualArtProfile(ArtProfileInspector profileInspector) {
+  private void inspectResidualArtProfile(ExternalArtProfile residualArtProfile) {
     // None of the items in the profile exist in the input.
     // TODO(b/266178791): Discard items from profile that is not in the input app.
-    profileInspector.assertNotEmpty();
+    assertEquals(getArtProfile(), residualArtProfile);
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/profile/art/NonEmptyToEmptyProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/NonEmptyToEmptyProfileRewritingTest.java
index 60e14df..4fb34a0 100644
--- a/src/test/java/com/android/tools/r8/profile/art/NonEmptyToEmptyProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/NonEmptyToEmptyProfileRewritingTest.java
@@ -7,12 +7,13 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
+import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -38,11 +39,12 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
-        .addArtProfileForRewriting(getArtProfile())
+        .apply(
+            ArtProfileTestingUtils.addArtProfileForRewriting(
+                getArtProfile(), this::inspectResidualArtProfile))
         .setMinApi(parameters.getApiLevel())
         .compile()
         .inspect(this::inspect)
-        .inspectResidualArtProfile(this::inspectResidualArtProfile)
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello, world!");
   }
@@ -60,9 +62,9 @@
     assertThat(mainClassSubject.uniqueMethodWithOriginalName("dead"), isAbsent());
   }
 
-  private void inspectResidualArtProfile(ArtProfileInspector profileInspector) {
+  private void inspectResidualArtProfile(ExternalArtProfile residualArtProfile) {
     // After shaking of Main.dead() the ART profile should become empty.
-    profileInspector.assertEmpty();
+    assertEquals(ExternalArtProfile.builder().build(), residualArtProfile);
   }
 
   static class Main {
diff --git a/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java b/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java
index 5b23bff..3e9ef1c 100644
--- a/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/completeness/SyntheticLambdaClassProfileRewritingTest.java
@@ -7,13 +7,14 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.onlyIf;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.profile.art.model.ExternalArtProfile;
 import com.android.tools.r8.profile.art.model.ExternalArtProfileMethodRule;
-import com.android.tools.r8.profile.art.utils.ArtProfileInspector;
+import com.android.tools.r8.profile.art.utils.ArtProfileTestingUtils;
 import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
 import com.android.tools.r8.utils.MethodReferenceUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -39,12 +40,14 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(getClass())
         .addKeepMainRule(Main.class)
-        .addArtProfileForRewriting(getArtProfile())
+        .apply(
+            testBuilder ->
+                ArtProfileTestingUtils.addArtProfileForRewriting(
+                    getArtProfile(), this::inspectResidualArtProfile, testBuilder))
         .noHorizontalClassMergingOfSynthetics()
         .setMinApi(parameters.getApiLevel())
         .compile()
         .inspect(this::inspect)
-        .inspectResidualArtProfile(this::inspectResidualArtProfile)
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("Hello, world!");
   }
@@ -68,14 +71,14 @@
         onlyIf(parameters.isDexRuntime(), isPresent()));
   }
 
-  private void inspectResidualArtProfile(ArtProfileInspector profileInspector) {
+  private void inspectResidualArtProfile(ExternalArtProfile residualArtProfile) {
     if (parameters.isCfRuntime()) {
-      profileInspector.assertEqualTo(getArtProfile());
+      assertEquals(getArtProfile(), residualArtProfile);
     } else {
       assert parameters.isDexRuntime();
       // TODO(b/265729283): Since Main.main() is in the art profile, so should the two synthetic
       //  lambdas be.
-      profileInspector.assertEqualTo(getArtProfile());
+      assertEquals(getArtProfile(), residualArtProfile);
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/profile/art/diagnostic/HumanReadableArtProfileParserErrorDiagnosticFromArtProfileTest.java b/src/test/java/com/android/tools/r8/profile/art/diagnostic/HumanReadableArtProfileParserErrorDiagnosticFromArtProfileTest.java
index c22ad2a..ba3a623 100644
--- a/src/test/java/com/android/tools/r8/profile/art/diagnostic/HumanReadableArtProfileParserErrorDiagnosticFromArtProfileTest.java
+++ b/src/test/java/com/android/tools/r8/profile/art/diagnostic/HumanReadableArtProfileParserErrorDiagnosticFromArtProfileTest.java
@@ -10,13 +10,20 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 
 import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.profile.art.ArtProfileBuilder;
+import com.android.tools.r8.profile.art.ArtProfileClassRuleInfo;
+import com.android.tools.r8.profile.art.ArtProfileConsumer;
+import com.android.tools.r8.profile.art.ArtProfileMethodRuleInfo;
 import com.android.tools.r8.profile.art.ArtProfileProvider;
+import com.android.tools.r8.profile.art.ArtProfileRuleConsumer;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.ConsumerUtils;
 import com.android.tools.r8.utils.UTF8TextInputStream;
@@ -42,7 +49,7 @@
   public void testD8() throws Exception {
     testForD8()
         .addProgramClasses(Main.class)
-        .addArtProfileForRewriting(createArtProfileProvider())
+        .addArtProfileForRewriting(createArtProfileProvider(), createArtProfileConsumer())
         .release()
         .setMinApi(AndroidApiLevel.LATEST)
         .compileWithExpectedDiagnostics(this::inspectDiagnostics);
@@ -53,7 +60,7 @@
     testForR8(Backend.DEX)
         .addProgramClasses(Main.class)
         .addKeepMainRule(Main.class)
-        .addArtProfileForRewriting(createArtProfileProvider())
+        .addArtProfileForRewriting(createArtProfileProvider(), createArtProfileConsumer())
         .release()
         .setMinApi(AndroidApiLevel.LATEST)
         .compileWithExpectedDiagnostics(this::inspectDiagnostics);
@@ -76,6 +83,34 @@
     };
   }
 
+  private ArtProfileConsumer createArtProfileConsumer() {
+    return new ArtProfileConsumer() {
+
+      @Override
+      public ArtProfileRuleConsumer getRuleConsumer() {
+        return new ArtProfileRuleConsumer() {
+
+          @Override
+          public void acceptClassRule(
+              ClassReference classReference, ArtProfileClassRuleInfo classRuleInfo) {
+            // Ignore.
+          }
+
+          @Override
+          public void acceptMethodRule(
+              MethodReference methodReference, ArtProfileMethodRuleInfo methodRuleInfo) {
+            // Ignore.
+          }
+        };
+      }
+
+      @Override
+      public void finished(DiagnosticsHandler handler) {
+        // Ignore.
+      }
+    };
+  }
+
   private void inspectDiagnostics(TestDiagnosticMessages diagnostics) {
     diagnostics.assertErrorsMatch(
         allOf(
diff --git a/src/test/java/com/android/tools/r8/profile/art/model/ExternalArtProfile.java b/src/test/java/com/android/tools/r8/profile/art/model/ExternalArtProfile.java
index 9dd4d42..0c3ae80 100644
--- a/src/test/java/com/android/tools/r8/profile/art/model/ExternalArtProfile.java
+++ b/src/test/java/com/android/tools/r8/profile/art/model/ExternalArtProfile.java
@@ -42,10 +42,6 @@
     }
   }
 
-  public int size() {
-    return rules.size();
-  }
-
   @Override
   public boolean equals(Object obj) {
     if (this == obj) {
diff --git a/src/test/java/com/android/tools/r8/profile/art/utils/ArtProfileInspector.java b/src/test/java/com/android/tools/r8/profile/art/utils/ArtProfileInspector.java
deleted file mode 100644
index af0a9a9..0000000
--- a/src/test/java/com/android/tools/r8/profile/art/utils/ArtProfileInspector.java
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) 2023, 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.profile.art.utils;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-
-import com.android.tools.r8.profile.art.model.ExternalArtProfile;
-
-public class ArtProfileInspector {
-
-  private final ExternalArtProfile artProfile;
-
-  public ArtProfileInspector(ExternalArtProfile artProfile) {
-    this.artProfile = artProfile;
-  }
-
-  public ArtProfileInspector assertEmpty() {
-    assertEquals(0, artProfile.size());
-    return this;
-  }
-
-  public ArtProfileInspector assertEqualTo(ExternalArtProfile otherArtProfile) {
-    assertEquals(otherArtProfile, artProfile);
-    return this;
-  }
-
-  public ArtProfileInspector assertNotEmpty() {
-    assertNotEquals(0, artProfile.size());
-    return this;
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/profile/art/utils/ArtProfileTestingUtils.java b/src/test/java/com/android/tools/r8/profile/art/utils/ArtProfileTestingUtils.java
index c86ad4d..697cb87 100644
--- a/src/test/java/com/android/tools/r8/profile/art/utils/ArtProfileTestingUtils.java
+++ b/src/test/java/com/android/tools/r8/profile/art/utils/ArtProfileTestingUtils.java
@@ -5,6 +5,9 @@
 package com.android.tools.r8.profile.art.utils;
 
 import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.desugar.desugaredlibrary.test.DesugaredLibraryTestBuilder;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.profile.art.ArtProfileBuilder;
 import com.android.tools.r8.profile.art.ArtProfileClassRuleInfo;
@@ -21,8 +24,38 @@
 
 public class ArtProfileTestingUtils {
 
+  public static <B extends R8TestBuilder<?>> ThrowableConsumer<B> addArtProfileForRewriting(
+      ExternalArtProfile artProfile, Consumer<ExternalArtProfile> residualArtProfileInspector) {
+    return testBuilder ->
+        testBuilder.addArtProfileForRewriting(
+            createArtProfileProvider(artProfile),
+            createResidualArtProfileConsumer(residualArtProfileInspector));
+  }
+
+  /**
+   * Adds the given {@param artProfile} as an ART profile for rewriting. The residual ART profile
+   * will be forwarded to the given test inspector, {@param residualArtProfileInspector}.
+   */
+  public static void addArtProfileForRewriting(
+      ExternalArtProfile artProfile,
+      Consumer<ExternalArtProfile> residualArtProfileInspector,
+      R8TestBuilder<?> testBuilder) {
+    testBuilder.addArtProfileForRewriting(
+        createArtProfileProvider(artProfile),
+        createResidualArtProfileConsumer(residualArtProfileInspector));
+  }
+
+  public static void addArtProfileForRewriting(
+      ExternalArtProfile artProfile,
+      Consumer<ExternalArtProfile> residualArtProfileInspector,
+      DesugaredLibraryTestBuilder<?> testBuilder) {
+    testBuilder.addL8ArtProfileForRewriting(
+        createArtProfileProvider(artProfile),
+        createResidualArtProfileConsumer(residualArtProfileInspector));
+  }
+
   // Creates an ArtProfileProvider for passing the given ART profile to a D8/L8/R8 compilation.
-  public static ArtProfileProvider createArtProfileProvider(ExternalArtProfile artProfile) {
+  private static ArtProfileProvider createArtProfileProvider(ExternalArtProfile artProfile) {
     return new ArtProfileProvider() {
 
       @Override
@@ -54,7 +87,7 @@
   }
 
   // Creates an ArtProfileConsumer for accepting the residual ART profile from the compilation.
-  public static ArtProfileConsumer createResidualArtProfileConsumer(
+  private static ArtProfileConsumer createResidualArtProfileConsumer(
       Consumer<ExternalArtProfile> residualArtProfileInspector) {
     return new ArtProfileConsumer() {
 
