diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 5a9ee16..a241a05 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -1545,10 +1545,6 @@
       timing.end();
     }
 
-    if (enumUnboxer != null && methodProcessor.isPrimaryMethodProcessor()) {
-      enumUnboxer.analyzeEnums(code);
-    }
-
     assert code.verifyTypes(appView);
 
     deadCodeRemover.run(code, timing);
@@ -1597,6 +1593,10 @@
       OptimizationFeedback feedback,
       MethodProcessor methodProcessor,
       Timing timing) {
+    if (enumUnboxer != null && methodProcessor.isPrimaryMethodProcessor()) {
+      enumUnboxer.analyzeEnums(code);
+    }
+
     if (libraryMethodOverrideAnalysis != null) {
       timing.begin("Analyze library method overrides");
       libraryMethodOverrideAnalysis.analyze(code);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
index f4c8028..5afd25d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxer.java
@@ -90,18 +90,29 @@
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.collections.ImmutableInt2ReferenceSortedMap;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
+import com.google.common.collect.HashMultiset;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.OptionalInt;
 import java.util.Set;
+import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
+import java.util.function.Function;
 import java.util.function.Predicate;
 
 public class EnumUnboxer {
@@ -121,7 +132,7 @@
   private EnumUnboxingRewriter enumUnboxerRewriter;
 
   private final boolean debugLogEnabled;
-  private final Map<DexType, Reason> debugLogs;
+  private final Map<DexType, List<Reason>> debugLogs;
 
   public EnumUnboxer(AppView<AppInfoWithLiveness> appView) {
     this.appView = appView;
@@ -149,10 +160,20 @@
     return ordinal + 1;
   }
 
-  private void markEnumAsUnboxable(Reason reason, DexProgramClass enumClass) {
+  /**
+   * Returns true if {@param enumClass} was marked as being unboxable.
+   *
+   * <p>Note that, if debug logging is enabled, {@param enumClass} is not marked unboxable until the
+   * enum unboxing analysis has finished. This is to ensure completeness of the reason reporting.
+   */
+  private boolean markEnumAsUnboxable(Reason reason, DexProgramClass enumClass) {
     assert enumClass.isEnum();
-    reportFailure(enumClass.type, reason);
-    enumUnboxingCandidatesInfo.removeCandidate(enumClass.type);
+    if (!reportFailure(enumClass, reason)) {
+      // The failure was not reported, meaning debug logging is disabled.
+      enumUnboxingCandidatesInfo.removeCandidate(enumClass);
+      return true;
+    }
+    return false;
   }
 
   private DexProgramClass getEnumUnboxingCandidateOrNull(TypeElement lattice) {
@@ -370,23 +391,30 @@
   }
 
   private Reason validateEnumUsages(IRCode code, Value value, DexProgramClass enumClass) {
+    Reason result = Reason.ELIGIBLE;
     for (Instruction user : value.uniqueUsers()) {
       Reason reason = instructionAllowEnumUnboxing(user, code, enumClass, value);
       if (reason != Reason.ELIGIBLE) {
-        markEnumAsUnboxable(reason, enumClass);
-        return reason;
+        if (markEnumAsUnboxable(reason, enumClass)) {
+          return reason;
+        }
+        // Record that the enum is ineligible, and continue analysis to collect all reasons for
+        // debugging.
+        result = reason;
       }
     }
     for (Phi phi : value.uniquePhiUsers()) {
       for (Value operand : phi.getOperands()) {
         if (!operand.getType().isNullType()
             && getEnumUnboxingCandidateOrNull(operand.getType()) != enumClass) {
+          // All reported reasons from here will be the same (INVALID_PHI), so just return
+          // immediately.
           markEnumAsUnboxable(Reason.INVALID_PHI, enumClass);
           return Reason.INVALID_PHI;
         }
       }
     }
-    return Reason.ELIGIBLE;
+    return result;
   }
 
   public void unboxEnums(
@@ -479,10 +507,12 @@
     analyzeInitializers();
     analyzeAccessibility();
     EnumDataMap enumDataMap = analyzeEnumInstances();
-    assert enumDataMap.getUnboxedEnums().size() == enumUnboxingCandidatesInfo.candidates().size();
     if (debugLogEnabled) {
+      // Remove all enums that have been reported as being unboxable.
+      debugLogs.keySet().forEach(enumUnboxingCandidatesInfo::removeCandidate);
       reportEnumsAnalysis();
     }
+    assert enumDataMap.getUnboxedEnums().size() == enumUnboxingCandidatesInfo.candidates().size();
     return enumDataMap;
   }
 
@@ -495,7 +525,9 @@
             markEnumAsUnboxable(Reason.MISSING_INSTANCE_FIELD_DATA, enumClass);
             return;
           }
-          builder.put(enumClass.type, data);
+          if (!debugLogEnabled || !debugLogs.containsKey(enumClass.getType())) {
+            builder.put(enumClass.type, data);
+          }
         });
     staticFieldValuesMap.clear();
     return new EnumDataMap(builder.build());
@@ -514,6 +546,9 @@
     EnumValuesObjectState valuesContents = null;
 
     EnumStaticFieldValues enumStaticFieldValues = staticFieldValuesMap.get(enumClass.type);
+    if (enumStaticFieldValues == null) {
+      return null;
+    }
 
     // Step 1: We iterate over the field to find direct enum instance information and the values
     // fields.
@@ -595,13 +630,6 @@
         valuesContents == null ? EnumData.INVALID_VALUES_SIZE : valuesContents.getEnumValuesSize());
   }
 
-  private boolean isFinalFieldInitialized(DexEncodedField staticField, DexProgramClass enumClass) {
-    assert staticField.isFinal();
-    return appView
-        .appInfo()
-        .isFieldOnlyWrittenInMethodIgnoringPinning(staticField, enumClass.getClassInitializer());
-  }
-
   private EnumInstanceFieldData computeEnumFieldData(
       DexField instanceField,
       DexProgramClass enumClass,
@@ -896,8 +924,9 @@
                   .getOptimizationInfo()
                   .getContextInsensitiveInstanceInitializerInfo()
                   .mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
-                markEnumAsUnboxable(Reason.INVALID_INIT, enumClass);
-                break;
+                if (markEnumAsUnboxable(Reason.INVALID_INIT, enumClass)) {
+                  break;
+                }
               }
             }
           }
@@ -905,12 +934,12 @@
             // This case typically happens when a programmer uses EnumSet/EnumMap without using the
             // enum keep rules. The code is incorrect in this case (EnumSet/EnumMap won't work).
             // We bail out.
-            markEnumAsUnboxable(Reason.NO_INIT, enumClass);
-            return;
+            if (markEnumAsUnboxable(Reason.NO_INIT, enumClass)) {
+              return;
+            }
           }
 
           if (enumClass.classInitializationMayHaveSideEffects(appView)) {
-            enumClass.classInitializationMayHaveSideEffects(appView);
             markEnumAsUnboxable(Reason.INVALID_CLINIT, enumClass);
           }
         });
@@ -1196,30 +1225,99 @@
 
   private void reportEnumsAnalysis() {
     assert debugLogEnabled;
-    Reporter reporter = appView.options().reporter;
+    Reporter reporter = appView.reporter();
     Set<DexType> candidates = enumUnboxingCandidatesInfo.candidates();
     reporter.info(
         new StringDiagnostic(
-            "Unboxed enums (Unboxing succeeded "
-                + candidates.size()
-                + "): "
-                + Arrays.toString(candidates.toArray())));
-    StringBuilder sb = new StringBuilder();
-    sb.append("Boxed enums (Unboxing failed ").append(debugLogs.size()).append("):\n");
-    for (DexType enumType : debugLogs.keySet()) {
-      sb.append("- ")
-          .append(enumType)
-          .append(": ")
-          .append(debugLogs.get(enumType).toString())
-          .append('\n');
+            "Unboxed " + candidates.size() + " enums: " + Arrays.toString(candidates.toArray())));
+
+    StringBuilder sb =
+        new StringBuilder("Unable to unbox ")
+            .append(debugLogs.size())
+            .append(" enums.")
+            .append(System.lineSeparator())
+            .append(System.lineSeparator());
+
+    // Sort by the number of reasons that prevent enum unboxing.
+    TreeMap<DexType, List<Reason>> sortedDebugLogs =
+        new TreeMap<>(
+            Comparator.<DexType>comparingInt(x -> debugLogs.get(x).size())
+                .thenComparing(Function.identity()));
+    sortedDebugLogs.putAll(debugLogs);
+
+    // Print the pinned enums and remove them from further reporting.
+    List<DexType> pinned = new ArrayList<>();
+    Iterator<Entry<DexType, List<Reason>>> sortedDebugLogIterator =
+        sortedDebugLogs.entrySet().iterator();
+    while (sortedDebugLogIterator.hasNext()) {
+      Entry<DexType, List<Reason>> entry = sortedDebugLogIterator.next();
+      List<Reason> reasons = entry.getValue();
+      if (reasons.size() > 1) {
+        break;
+      }
+      if (reasons.get(0) == Reason.PINNED) {
+        pinned.add(entry.getKey());
+        sortedDebugLogIterator.remove();
+      }
     }
+    if (!pinned.isEmpty()) {
+      sb.append("Pinned: ").append(Arrays.toString(pinned.toArray()));
+    }
+
+    // Print the reasons for each unboxable enum.
+    sortedDebugLogs.forEach(
+        (type, reasons) -> {
+          sb.append(type).append(" (").append(reasons.size()).append(" reasons):");
+          HashMultiset.create(reasons)
+              .forEachEntry(
+                  (reason, count) ->
+                      sb.append(System.lineSeparator())
+                          .append(" - ")
+                          .append(reason)
+                          .append(" (")
+                          .append(count)
+                          .append(")"));
+          sb.append(System.lineSeparator());
+        });
+
+    sb.append(System.lineSeparator());
+
+    // Print information about how often a given Reason kind prevents enum unboxing.
+    Object2IntMap<Reason> reasonCount = new Object2IntOpenHashMap<>();
+    debugLogs.forEach(
+        (type, reasons) ->
+            reasons.forEach(reason -> reasonCount.put(reason, reasonCount.getInt(reason) + 1)));
+    List<Reason> differentReasons = new ArrayList<>(reasonCount.keySet());
+    differentReasons.sort(
+        (x, y) -> {
+          int freq = reasonCount.getInt(x) - reasonCount.getInt(y);
+          return freq != 0 ? freq : System.identityHashCode(x) - System.identityHashCode(y);
+        });
+    differentReasons.forEach(
+        x -> {
+          sb.append(x)
+              .append(" (")
+              .append(reasonCount.getInt(x))
+              .append(")")
+              .append(System.lineSeparator());
+        });
+
     reporter.info(new StringDiagnostic(sb.toString()));
   }
 
-  void reportFailure(DexType enumType, Reason reason) {
+  boolean reportFailure(DexProgramClass enumClass, Reason reason) {
+    return reportFailure(enumClass.getType(), reason);
+  }
+
+  /** Returns true if the failure was reported. */
+  boolean reportFailure(DexType enumType, Reason reason) {
     if (debugLogEnabled) {
-      debugLogs.put(enumType, reason);
+      debugLogs
+          .computeIfAbsent(enumType, ignore -> Collections.synchronizedList(new ArrayList<>()))
+          .add(reason);
+      return true;
     }
+    return false;
   }
 
   public Set<Phi> rewriteCode(IRCode code) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
index 9196ca3..c45e71a9 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateAnalysis.java
@@ -53,19 +53,29 @@
     if (!clazz.isEnum()) {
       return false;
     }
+
+    boolean result = true;
     if (clazz.superType != factory.enumType || !clazz.isEffectivelyFinal(appView)) {
-      enumUnboxer.reportFailure(clazz.type, Reason.SUBTYPES);
-      return false;
+      if (!enumUnboxer.reportFailure(clazz, Reason.SUBTYPES)) {
+        return false;
+      }
+      // Record that `clazz` is ineligible, and continue analysis to ensure all reasons are reported
+      // for debugging.
+      result = false;
     }
     if (clazz.instanceFields().size() > MAX_INSTANCE_FIELDS_FOR_UNBOXING) {
-      enumUnboxer.reportFailure(clazz.type, Reason.MANY_INSTANCE_FIELDS);
-      return false;
+      if (!enumUnboxer.reportFailure(clazz, Reason.MANY_INSTANCE_FIELDS)) {
+        return false;
+      }
+      result = false;
     }
     if (!enumHasBasicStaticFields(clazz)) {
-      enumUnboxer.reportFailure(clazz.type, Reason.UNEXPECTED_STATIC_FIELD);
-      return false;
+      if (!enumUnboxer.reportFailure(clazz, Reason.UNEXPECTED_STATIC_FIELD)) {
+        return false;
+      }
+      result = false;
     }
-    return true;
+    return result;
   }
 
   // The enum should have the $VALUES static field and only fields directly referencing the enum
@@ -116,8 +126,9 @@
           || appView.options().testing.allowInjectedAnnotationMethods;
       DexType valueType = method.returnType().toBaseType(appView.dexItemFactory());
       if (enumToUnboxCandidates.isCandidate(valueType)) {
-        enumUnboxer.reportFailure(valueType, Reason.ANNOTATION);
-        enumToUnboxCandidates.removeCandidate(valueType);
+        if (!enumUnboxer.reportFailure(valueType, Reason.ANNOTATION)) {
+          enumToUnboxCandidates.removeCandidate(valueType);
+        }
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateInfoCollection.java b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateInfoCollection.java
index 947cc6d..f36474d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/enums/EnumUnboxingCandidateInfoCollection.java
@@ -26,6 +26,10 @@
     enumTypeToInfo.put(enumClass.type, new EnumUnboxingCandidateInfo(enumClass));
   }
 
+  public void removeCandidate(DexProgramClass enumClass) {
+    removeCandidate(enumClass.getType());
+  }
+
   public void removeCandidate(DexType enumType) {
     enumTypeToInfo.remove(enumType);
   }
diff --git a/src/test/java/com/android/tools/r8/SingleTestRunResult.java b/src/test/java/com/android/tools/r8/SingleTestRunResult.java
index 07e0736..17546ee 100644
--- a/src/test/java/com/android/tools/r8/SingleTestRunResult.java
+++ b/src/test/java/com/android/tools/r8/SingleTestRunResult.java
@@ -50,6 +50,11 @@
     return result.stdout;
   }
 
+  public <E extends Throwable> RR inspectStdOut(ThrowingConsumer<String, E> consumer) throws E {
+    consumer.accept(getStdOut());
+    return self();
+  }
+
   public String getStdErr() {
     return result.stderr;
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
index 0bc6b67..6382436 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/AnnotationEnumUnboxingTest.java
@@ -49,26 +49,22 @@
         .addKeepRules(enumKeepRules.getKeepRules())
         .addKeepClassRules(ClassAnnotationDefault.class)
         .addKeepRuntimeVisibleAnnotations()
+        .addEnumUnboxingInspector(
+            inspector ->
+                inspector
+                    .assertUnboxed(MyEnumParamMethod2.class, MyEnumRetMethod2.class)
+                    .assertNotUnboxed(
+                        MyEnum.class,
+                        MyEnumDefault.class,
+                        MyEnumArray.class,
+                        MyEnumArrayDefault.class))
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .enableMemberValuePropagationAnnotations()
         .enableNoVerticalClassMergingAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-        .allowDiagnosticInfoMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
-        .inspectDiagnosticMessages(
-            m -> {
-              assertEnumIsBoxed(MyEnumDefault.class, MyEnumDefault.class.getSimpleName(), m);
-              assertEnumIsBoxed(MyEnum.class, MyEnum.class.getSimpleName(), m);
-              assertEnumIsBoxed(
-                  MyEnumArrayDefault.class, MyEnumArrayDefault.class.getSimpleName(), m);
-              assertEnumIsBoxed(MyEnumArray.class, MyEnumArray.class.getSimpleName(), m);
-              assertEnumIsUnboxed(
-                  MyEnumRetMethod2.class, MyEnumRetMethod2.class.getSimpleName(), m);
-              assertEnumIsUnboxed(
-                  MyEnumParamMethod2.class, MyEnumParamMethod2.class.getSimpleName(), m);
-            })
         .run(parameters.getRuntime(), Main.class)
         .assertSuccessWithOutputLines("print", "1", "1", "1", "1", "1", "0", "0", "0", "0");
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java
index 67dfbc0..743a819 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ClInitSideEffectEnumUnboxingTest.java
@@ -7,7 +7,6 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoHorizontalClassMerging;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -37,23 +36,20 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<Switch> classToTest = Switch.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ClInitSideEffectEnumUnboxingTest.class)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableInliningAnnotations()
-            .enableNoHorizontalClassMergingAnnotations()
-            .enableNeverClassInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(MyEnum.class, classToTest.getSimpleName(), m))
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(ClInitSideEffectEnumUnboxingTest.class)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class))
+        .enableInliningAnnotations()
+        .enableNoHorizontalClassMergingAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ClassAccessEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ClassAccessEnumUnboxingTest.java
index a39e30f..a24cb93 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ClassAccessEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ClassAccessEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Assume;
@@ -37,27 +36,23 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Assume.assumeTrue("studio rules required to use valueOf", enumKeepRules.isStudio());
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ClassAccessEnumUnboxingTest.class)
-            .addKeepMainRule(Main.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> {
-                  assertEnumIsUnboxed(ProtoEnumLike.class, ProtoEnumLike.class.getSimpleName(), m);
-                  assertEnumIsUnboxed(UnboxableEnum.class, UnboxableEnum.class.getSimpleName(), m);
-                  assertEnumIsBoxed(EscapingEnum1.class, EscapingEnum1.class.getSimpleName(), m);
-                  assertEnumIsBoxed(EscapingEnum2.class, EscapingEnum2.class.getSimpleName(), m);
-                })
-            .run(parameters.getRuntime(), Main.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(ClassAccessEnumUnboxingTest.class)
+        .addKeepMainRule(Main.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(
+            inspector ->
+                inspector
+                    .assertUnboxed(ProtoEnumLike.class, UnboxableEnum.class)
+                    .assertNotUnboxed(EscapingEnum1.class, EscapingEnum2.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ComparisonEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ComparisonEnumUnboxingTest.java
index 9873711..91c9afd 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ComparisonEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ComparisonEnumUnboxingTest.java
@@ -8,8 +8,8 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
+import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -47,7 +47,11 @@
             .enableNeverClassInliningAnnotations()
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
+            .addEnumUnboxingInspector(
+                inspector ->
+                    Arrays.stream(INPUTS)
+                        .map(clazz -> (Class<? extends Enum<?>>) clazz.getDeclaredClasses()[0])
+                        .forEach(inspector::assertUnboxed))
             .setMinApi(parameters.getApiLevel())
             .compile()
             .inspect(
@@ -56,13 +60,10 @@
                   assertEquals(2, inspector.clazz(EnumComparison.class).allMethods().size());
                 });
     for (Class<?> input : INPUTS) {
-      R8TestRunResult run =
-          compile
-              .inspectDiagnosticMessages(
-                  m -> assertEnumIsUnboxed(input.getDeclaredClasses()[0], input.getSimpleName(), m))
-              .run(parameters.getRuntime(), input)
-              .assertSuccess();
-      assertLines2By2Correct(run.getStdOut());
+      compile
+          .run(parameters.getRuntime(), input)
+          .assertSuccess()
+          .inspectStdOut(this::assertLines2By2Correct);
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
index e9a7e5d..0326e0b 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingEnumUnboxingTest.java
@@ -7,8 +7,8 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.enumunboxing.DoubleProcessingEnumUnboxingTest.App.AppEnum;
 import com.android.tools.r8.enumunboxing.examplelib1.JavaLibrary1;
 import com.android.tools.r8.ir.optimize.enums.UnboxedEnumMemberRelocator;
 import com.android.tools.r8.references.Reference;
@@ -67,24 +67,21 @@
             .compile()
             .writeToZip();
     // Compile the app with the lib.
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(App.class, App.AppEnum.class)
-            .addProgramFiles(javaLibShrunk)
-            .addKeepMainRule(App.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspect(this::assertUtilityClassPresent)
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(App.AppEnum.class, App.class.getSimpleName(), m))
-            .run(parameters.getRuntime(), App.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(App.class, App.AppEnum.class)
+        .addProgramFiles(javaLibShrunk)
+        .addKeepMainRule(App.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(App.AppEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::assertUtilityClassPresent)
+        .run(parameters.getRuntime(), App.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   private void assertUtilityClassPresent(CodeInspector codeInspector) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
index 7cc81c3..44cdff0 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/DoubleProcessingMergeEnumUnboxingTest.java
@@ -7,7 +7,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.enumunboxing.examplelib1.JavaLibrary1;
 import com.android.tools.r8.enumunboxing.examplelib2.JavaLibrary2;
@@ -58,24 +57,21 @@
     Path javaLibShrunk1 = compileLibrary(JavaLibrary1.class, JavaLibrary1.LibEnum1.class);
     Path javaLibShrunk2 = compileLibrary(JavaLibrary2.class, JavaLibrary2.LibEnum2.class);
     // Compile the app with the lib.
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(App.class, App.AppEnum.class)
-            .addProgramFiles(javaLibShrunk1, javaLibShrunk2)
-            .addKeepMainRule(App.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspect(this::assertUtilityClassPresent)
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(App.AppEnum.class, App.class.getSimpleName(), m))
-            .run(parameters.getRuntime(), App.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(App.class, App.AppEnum.class)
+        .addProgramFiles(javaLibShrunk1, javaLibShrunk2)
+        .addKeepMainRule(App.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(App.AppEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::assertUtilityClassPresent)
+        .run(parameters.getRuntime(), App.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   private Path compileLibrary(Class<?> libClass, Class<?> enumLibClass) throws Exception {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
index ddc0806..34a9d32 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EmptyEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -35,24 +34,20 @@
 
   @Test
   public void testEnumUnboxing() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(EmptyEnumUnboxingTest.class)
-            .addKeepMainRule(Main.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m ->
-                    // TODO(b/166532373): Unbox enum with no cases.
-                    assertEnumIsBoxed(MyEnum.class, Main.class.getSimpleName(), m))
-            .run(parameters.getRuntime(), Main.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(EmptyEnumUnboxingTest.class)
+        .addKeepMainRule(Main.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        // TODO(b/166532373): Unbox enum with no cases.
+        .addEnumUnboxingInspector(inspector -> inspector.assertNotUnboxed(MyEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumMissingFieldsUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumMissingFieldsUnboxingTest.java
index f6b55cf..e46a48c 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumMissingFieldsUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumMissingFieldsUnboxingTest.java
@@ -7,7 +7,6 @@
 import static org.hamcrest.CoreMatchers.containsString;
 
 import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.io.IOException;
 import java.util.List;
@@ -37,22 +36,19 @@
 
   @Test
   public void testEnumUnboxing() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(TestClass.class)
-            .addProgramClassFileData(getEnumProgramData())
-            .addKeepMainRule(TestClass.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsBoxed(CompilationEnum.class, TestClass.class.getSimpleName(), m))
-            .run(parameters.getRuntime(), TestClass.class)
-            .assertFailureWithErrorThatMatches(containsString("NoSuchFieldError"));
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(TestClass.class)
+        .addProgramClassFileData(getEnumProgramData())
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertNotUnboxed(CompilationEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertFailureWithErrorThatMatches(containsString("NoSuchFieldError"))
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   private byte[] getEnumProgramData() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
index b21cbd0..0d7a5dfc 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumToStringLibTest.java
@@ -70,9 +70,7 @@
                   options.enableEnumUnboxing = enumUnboxing;
                   options.enableEnumValueOptimization = enumValueOptimization;
                   options.enableEnumSwitchMapRemoval = enumValueOptimization;
-                  options.testing.enableEnumUnboxingDebugLogs = enumUnboxing;
                 })
-            .allowDiagnosticInfoMessages(enumUnboxing)
             .setMinApi(parameters.getApiLevel())
             .compile();
       compile
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingArrayTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingArrayTest.java
index d4b73ff..b28b0b1 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingArrayTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingArrayTest.java
@@ -7,7 +7,6 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -18,12 +17,12 @@
 @RunWith(Parameterized.class)
 public class EnumUnboxingArrayTest extends EnumUnboxingTestBase {
 
-  private static final Class<?>[] SUCCESSES = {
-    EnumVarArgs.class,
-    EnumArrayReadWriteNoEscape.class,
-    EnumArrayReadWrite.class,
+  private static final Class<?>[] TESTS = {
+    Enum2DimArrayReadWrite.class,
     EnumArrayNullRead.class,
-    Enum2DimArrayReadWrite.class
+    EnumArrayReadWrite.class,
+    EnumArrayReadWriteNoEscape.class,
+    EnumVarArgs.class,
   };
 
   private final TestParameters parameters;
@@ -47,24 +46,29 @@
     R8TestCompileResult compile =
         testForR8(parameters.getBackend())
             .addInnerClasses(EnumUnboxingArrayTest.class)
-            .addKeepMainRules(SUCCESSES)
+            .addKeepMainRules(TESTS)
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
+            .addEnumUnboxingInspector(
+                inspector ->
+                    inspector
+                        .assertUnboxed(
+                            EnumArrayReadWrite.MyEnum.class,
+                            EnumArrayReadWriteNoEscape.MyEnum.class,
+                            EnumVarArgs.MyEnum.class)
+                        // TODO(b/185182242): Should always be unboxed.
+                        .assertUnboxedIf(enumKeepRules.isStudio(), EnumArrayNullRead.MyEnum.class)
+                        // TODO(b/185182242): Should always be unboxed.
+                        .assertNotUnboxed(Enum2DimArrayReadWrite.MyEnum.class))
             .setMinApi(parameters.getApiLevel())
             .compile();
-    for (Class<?> success : SUCCESSES) {
-      R8TestRunResult run =
-          compile
-              .inspectDiagnosticMessages(
-                  m ->
-                      assertEnumIsUnboxed(
-                          success.getDeclaredClasses()[0], success.getSimpleName(), m))
-              .run(parameters.getRuntime(), success)
-              .assertSuccess();
-      assertLines2By2Correct(run.getStdOut());
+    for (Class<?> main : TESTS) {
+      compile
+          .run(parameters.getRuntime(), main)
+          .assertSuccess()
+          .inspectStdOut(this::assertLines2By2Correct);
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
index 590cc7c..a8fe3f9 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingB160535628Test.java
@@ -7,7 +7,6 @@
 import static org.hamcrest.core.StringContains.containsString;
 
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.BooleanUtils;
 import java.nio.file.Path;
@@ -50,18 +49,14 @@
             .addProgramFiles(javaLibShrunk)
             .addKeepMainRules(ProgramValueOf.class, ProgramStaticMethod.class)
             .addKeepRules(enumKeepRules.getKeepRules())
-            .addOptionsModification(
-                options -> {
-                  assert options.enableEnumUnboxing;
-                  options.testing.enableEnumUnboxingDebugLogs = true;
-                })
+            .addEnumUnboxingInspector(
+                inspector ->
+                    inspector
+                        .assertUnboxed(Lib.LibEnum.class)
+                        .assertUnboxedIf(!missingStaticMethods, Lib.LibEnumStaticMethod.class))
             .allowDiagnosticMessages()
             .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                // The enums cannot be unboxed if static methods are missing,
-                // but they should be unboxed otherwise.
-                this::assertEnumUnboxedIfStaticMethodsPresent);
+            .compile();
     if (missingStaticMethods) {
       compile
           .run(parameters.getRuntime(), ProgramStaticMethod.class)
@@ -92,36 +87,19 @@
         .addKeepRules(missingStaticMethods ? "" : "-keep enum * { static <methods>; }")
         .addOptionsModification(
             options -> {
+              assert !options.enableEnumUnboxing;
               options.enableEnumUnboxing = true;
-              options.testing.enableEnumUnboxingDebugLogs = true;
             })
         .addKeepClassRules(Lib.LibEnumStaticMethod.class)
+        .addEnumUnboxingInspector(
+            inspector ->
+                inspector.assertNotUnboxed(Lib.LibEnum.class, Lib.LibEnumStaticMethod.class))
         .allowDiagnosticMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
-        .inspectDiagnosticMessages(
-            msg -> {
-              assertEnumIsBoxed(
-                  Lib.LibEnumStaticMethod.class,
-                  Lib.LibEnumStaticMethod.class.getSimpleName(),
-                  msg);
-              assertEnumIsBoxed(Lib.LibEnum.class, Lib.LibEnum.class.getSimpleName(), msg);
-            })
         .writeToZip();
   }
 
-  private void assertEnumUnboxedIfStaticMethodsPresent(TestDiagnosticMessages msg) {
-    if (missingStaticMethods) {
-      assertEnumIsBoxed(
-          Lib.LibEnumStaticMethod.class, Lib.LibEnumStaticMethod.class.getSimpleName(), msg);
-      assertEnumIsBoxed(Lib.LibEnum.class, Lib.LibEnum.class.getSimpleName(), msg);
-    } else {
-      assertEnumIsUnboxed(
-          Lib.LibEnumStaticMethod.class, Lib.LibEnumStaticMethod.class.getSimpleName(), msg);
-      assertEnumIsUnboxed(Lib.LibEnum.class, Lib.LibEnum.class.getSimpleName(), msg);
-    }
-  }
-
   public static class Lib {
 
     public enum LibEnumStaticMethod {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
index 750c6fe..c531710 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingClassStaticizerTest.java
@@ -10,7 +10,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
@@ -40,28 +39,21 @@
 
   @Test
   public void testEnumUnboxing() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(EnumUnboxingClassStaticizerTest.class)
-            .addKeepMainRule(TestClass.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .noMinification() // For assertions.
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspect(this::assertClassStaticized)
-            .inspectDiagnosticMessages(
-                m ->
-                    assertEnumIsUnboxed(
-                        UnboxableEnum.class,
-                        EnumUnboxingClassStaticizerTest.class.getSimpleName(),
-                        m))
-            .run(parameters.getRuntime(), TestClass.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(EnumUnboxingClassStaticizerTest.class)
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(UnboxableEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .noMinification() // For assertions.
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::assertClassStaticized)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   private void assertClassStaticized(CodeInspector codeInspector) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingReturnNullTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingReturnNullTest.java
index a0173b5..392807c 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingReturnNullTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingReturnNullTest.java
@@ -16,7 +16,7 @@
 @RunWith(Parameterized.class)
 public class EnumUnboxingReturnNullTest extends EnumUnboxingTestBase {
 
-  private static final Class<?> ENUM_CLASS = MyEnum.class;
+  private static final Class<MyEnum> ENUM_CLASS = MyEnum.class;
   private static final String EXPECTED_RESULT =
       StringUtils.lines(
           "print1", "true", "print2", "true", "print2", "false", "0", "print3", "true");
@@ -44,14 +44,12 @@
         .addProgramClasses(classToTest, ENUM_CLASS)
         .addKeepMainRule(classToTest)
         .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(ENUM_CLASS))
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-        .allowDiagnosticInfoMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
-        .inspectDiagnosticMessages(
-            m -> assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m))
         .run(parameters.getRuntime(), classToTest)
         .assertSuccessWithOutput(EXPECTED_RESULT);
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java
index 89621a2..3475ecf 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingSideEffectClInitTest.java
@@ -14,7 +14,7 @@
 
 @RunWith(Parameterized.class)
 public class EnumUnboxingSideEffectClInitTest extends EnumUnboxingTestBase {
-  private static final Class<?> ENUM_CLASS = MyEnum.class;
+  private static final Class<MyEnum> ENUM_CLASS = MyEnum.class;
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
   private final EnumKeepRules enumKeepRules;
@@ -38,13 +38,11 @@
         .addInnerClasses(EnumUnboxingSideEffectClInitTest.class)
         .addKeepMainRule(classToTest)
         .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(ENUM_CLASS))
         .enableNeverClassInliningAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-        .allowDiagnosticInfoMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
-        .inspectDiagnosticMessages(
-            m -> assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m))
         .run(parameters.getRuntime(), classToTest)
         .assertSuccessWithOutputLines("0");
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java
index c494152..c36733b 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingTestBase.java
@@ -5,11 +5,8 @@
 package com.android.tools.r8.enumunboxing;
 
 import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertTrue;
 
-import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestDiagnosticMessages;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.InternalOptions;
@@ -35,6 +32,10 @@
       return keepRules;
     }
 
+    public boolean isNone() {
+      return this == NONE;
+    }
+
     public boolean isStudio() {
       return this == STUDIO;
     }
@@ -58,32 +59,6 @@
   protected void enableEnumOptions(InternalOptions options, boolean enumValueOptimization) {
     options.enableEnumValueOptimization = enumValueOptimization;
     options.enableEnumSwitchMapRemoval = enumValueOptimization;
-    options.testing.enableEnumUnboxingDebugLogs = true;
-  }
-
-  protected void assertEnumIsUnboxed(
-      Class<?> enumClass, String testName, TestDiagnosticMessages m) {
-    assertTrue(enumClass.isEnum());
-    assertEnumIsUnboxed(enumClass.getSimpleName(), testName, m);
-  }
-
-  protected void assertEnumIsUnboxed(String enumClass, String testName, TestDiagnosticMessages m) {
-    Diagnostic diagnostic = m.getInfos().get(0);
-    assertTrue(diagnostic.getDiagnosticMessage().startsWith("Unboxed enums"));
-    assertTrue(
-        StringUtils.joinLines(
-            "Expected enum to be removed (" + testName + "):",
-            m.getInfos().get(1).getDiagnosticMessage()),
-        diagnostic.getDiagnosticMessage().contains(enumClass));
-  }
-
-  void assertEnumIsBoxed(Class<?> enumClass, String testName, TestDiagnosticMessages m) {
-    assertTrue(enumClass.isEnum());
-    Diagnostic diagnostic = m.getInfos().get(1);
-    assertTrue(diagnostic.getDiagnosticMessage().startsWith("Boxed enums"));
-    assertTrue(
-        "Expected enum NOT to be removed (" + testName + ")",
-        diagnostic.getDiagnosticMessage().contains(enumClass.getSimpleName()));
   }
 
   static List<Object[]> enumUnboxingTestParameters() {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingVerticalClassMergeTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingVerticalClassMergeTest.java
index d8396cb..f240835 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingVerticalClassMergeTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumUnboxingVerticalClassMergeTest.java
@@ -8,7 +8,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.util.List;
@@ -37,28 +36,21 @@
 
   @Test
   public void testEnumUnboxing() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(EnumUnboxingVerticalClassMergeTest.class)
-            .addKeepMainRule(Main.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .noMinification() // For assertions.
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspect(this::assertVerticalClassMerged)
-            .inspectDiagnosticMessages(
-                m ->
-                    assertEnumIsUnboxed(
-                        UnboxableEnum.class,
-                        EnumUnboxingVerticalClassMergeTest.class.getSimpleName(),
-                        m))
-            .run(parameters.getRuntime(), Main.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(EnumUnboxingVerticalClassMergeTest.class)
+        .addKeepMainRule(Main.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(UnboxableEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .noMinification() // For assertions.
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::assertVerticalClassMerged)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   private void assertVerticalClassMerged(CodeInspector codeInspector) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EqualsCompareToEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EqualsCompareToEnumUnboxingTest.java
index 2888ee4..4e38f3f 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/EqualsCompareToEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EqualsCompareToEnumUnboxingTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.enumunboxing;
 
 import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -35,23 +34,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> success = EnumEqualscompareTo.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(EqualsCompareToEnumUnboxingTest.class)
-            .addKeepMainRule(EnumEqualscompareTo.class)
-            .enableNeverClassInliningAnnotations()
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m ->
-                    assertEnumIsUnboxed(
-                        success.getDeclaredClasses()[0], success.getSimpleName(), m))
-            .run(parameters.getRuntime(), success)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(EqualsCompareToEnumUnboxingTest.class)
+        .addKeepMainRule(EnumEqualscompareTo.class)
+        .addEnumUnboxingInspector(
+            inspector -> inspector.assertUnboxed(EnumEqualscompareTo.MyEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), success)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   static class EnumEqualscompareTo {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java
index 8bf8034..e3df746 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingEnumUnboxingTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.enumunboxing;
 
 import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -34,25 +33,19 @@
 
   @Test
   public void testEnumUnboxingFailure() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(FailingEnumUnboxingTest.class)
-            .addKeepMainRule(EnumStaticFieldMain.class)
-            .enableNeverClassInliningAnnotations()
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m ->
-                    assertEnumIsBoxed(
-                        EnumStaticFieldMain.EnumStaticField.class,
-                        EnumStaticFieldMain.class.getSimpleName(),
-                        m))
-            .run(parameters.getRuntime(), EnumStaticFieldMain.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(FailingEnumUnboxingTest.class)
+        .addKeepMainRule(EnumStaticFieldMain.class)
+        .enableNeverClassInliningAnnotations()
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .addEnumUnboxingInspector(
+            inspector -> inspector.assertNotUnboxed(EnumStaticFieldMain.EnumStaticField.class))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), EnumStaticFieldMain.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   static class EnumStaticFieldMain {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
index 702ce3e..cde02a3 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FailingMethodEnumUnboxingTest.java
@@ -9,9 +9,10 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.SingleTestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.List;
 import org.junit.Test;
@@ -53,27 +54,24 @@
             .addKeepMainRules(FAILURES)
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
+            .addEnumUnboxingInspector(
+                inspector ->
+                    Arrays.stream(FAILURES)
+                        .map(clazz -> (Class<? extends Enum<?>>) clazz.getDeclaredClasses()[0])
+                        .forEach(inspector::assertNotUnboxed))
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
             .setMinApi(parameters.getApiLevel())
             .compile()
             .inspect(this::assertEnumsAsExpected);
     for (Class<?> failure : FAILURES) {
-      R8TestRunResult run =
-          compile
-              .inspectDiagnosticMessages(
-                  m ->
-                      assertEnumIsBoxed(
-                          failure.getDeclaredClasses()[0], failure.getSimpleName(), m))
-              .run(parameters.getRuntime(), failure);
-      if (failure == EnumSetTest.class && enumKeepRules.getKeepRules().isEmpty()) {
-        // EnumSet and EnumMap cannot be used without the enumKeepRules.
-        run.assertFailure();
-      } else {
-        run.assertSuccess();
-        assertLines2By2Correct(run.getStdOut());
-      }
+      compile
+          .run(parameters.getRuntime(), failure)
+          .applyIf(
+              failure == EnumSetTest.class && enumKeepRules.getKeepRules().isEmpty(),
+              // EnumSet and EnumMap cannot be used without the enumKeepRules.
+              SingleTestRunResult::assertFailure,
+              result -> result.assertSuccess().inspectStdOut(this::assertLines2By2Correct));
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingTest.java
index 4d222d5..ad40e78 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/FieldPutEnumUnboxingTest.java
@@ -9,8 +9,8 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
+import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -47,7 +47,11 @@
             .addKeepMainRules(INPUTS)
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
+            .addEnumUnboxingInspector(
+                inspector ->
+                    Arrays.stream(INPUTS)
+                        .map(clazz -> (Class<? extends Enum<?>>) clazz.getDeclaredClasses()[0])
+                        .forEach(inspector::assertUnboxed))
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
             .setMinApi(parameters.getApiLevel())
@@ -63,13 +67,10 @@
                 });
 
     for (Class<?> input : INPUTS) {
-      R8TestRunResult run =
-          compile
-              .inspectDiagnosticMessages(
-                  m -> assertEnumIsUnboxed(input.getDeclaredClasses()[0], input.getSimpleName(), m))
-              .run(parameters.getRuntime(), input)
-              .assertSuccess();
-      assertLines2By2Correct(run.getStdOut());
+      compile
+          .run(parameters.getRuntime(), input)
+          .assertSuccess()
+          .inspectStdOut(this::assertLines2By2Correct);
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/InstanceFieldsEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/InstanceFieldsEnumUnboxingTest.java
index dc21961..61bd347 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/InstanceFieldsEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/InstanceFieldsEnumUnboxingTest.java
@@ -7,8 +7,8 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
+import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -20,7 +20,6 @@
 
   private static final Class<?>[] FAILURES = {
     FailureIntField.class,
-    FailurePrivateIntField.class,
     FailureBoxedInnerEnumField.class,
     FailureUnboxedEnumField.class,
     FailureTooManyUsedFields.class
@@ -34,6 +33,7 @@
     SuccessIntFieldInitializerInit.class,
     SuccessStringField.class,
     SuccessMultiConstructorIntField.class,
+    SuccessPrivateIntField.class,
   };
 
   private final TestParameters parameters;
@@ -59,42 +59,45 @@
             .addInnerClasses(InstanceFieldsEnumUnboxingTest.class)
             .addKeepMainRules(SUCCESSES)
             .addKeepMainRules(FAILURES)
+            .addEnumUnboxingInspector(
+                inspector -> {
+                  Arrays.stream(SUCCESSES)
+                      .flatMap(
+                          clazz -> Arrays.stream(clazz.getDeclaredClasses()).filter(Class::isEnum))
+                      .forEach(clazz -> inspector.assertUnboxed((Class<? extends Enum<?>>) clazz));
+                  Arrays.stream(FAILURES)
+                      .flatMap(
+                          clazz ->
+                              Arrays.stream(clazz.getDeclaredClasses())
+                                  .filter(
+                                      declaredClass ->
+                                          declaredClass.isEnum()
+                                              && !declaredClass
+                                                  .getSimpleName()
+                                                  .equals("InnerEnum")))
+                      .forEach(
+                          clazz -> inspector.assertNotUnboxed((Class<? extends Enum<?>>) clazz));
+                })
             .noMinification()
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile();
     for (Class<?> failure : FAILURES) {
-      testClass(compile, failure, true);
+      testClass(compile, failure);
     }
     for (Class<?> success : SUCCESSES) {
-      testClass(compile, success, false);
+      testClass(compile, success);
     }
   }
 
-  private void testClass(R8TestCompileResult compile, Class<?> testClass, boolean failure)
-      throws Exception {
-    R8TestRunResult run =
-        compile
-            .inspectDiagnosticMessages(
-                m -> {
-                  for (Class<?> declaredClass : testClass.getDeclaredClasses()) {
-                    if (declaredClass.isEnum()
-                        && !declaredClass.getSimpleName().equals("InnerEnum")) {
-                      if (failure) {
-                        assertEnumIsBoxed(declaredClass, testClass.getSimpleName(), m);
-                      } else {
-                        assertEnumIsUnboxed(declaredClass, testClass.getSimpleName(), m);
-                      }
-                    }
-                  }
-                })
-            .run(parameters.getRuntime(), testClass)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+  private void testClass(R8TestCompileResult compile, Class<?> testClass) throws Exception {
+    compile
+        .run(parameters.getRuntime(), testClass)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   static class SuccessUnusedField {
@@ -161,7 +164,7 @@
     }
   }
 
-  static class FailurePrivateIntField {
+  static class SuccessPrivateIntField {
 
     public static void main(String[] args) {
       System.out.println(getEnumA().field);
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
index 7311ab2..2f70afd 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/InterfaceEnumUnboxingTest.java
@@ -8,8 +8,8 @@
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoVerticalClassMerging;
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
+import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -54,42 +54,39 @@
             .addInnerClasses(InterfaceEnumUnboxingTest.class)
             .addKeepMainRules(SUCCESSES)
             .addKeepMainRules(FAILURES)
+            .addEnumUnboxingInspector(
+                inspector -> {
+                  Arrays.stream(SUCCESSES)
+                      .flatMap(
+                          clazz -> Arrays.stream(clazz.getDeclaredClasses()).filter(Class::isEnum))
+                      .forEach(clazz -> inspector.assertUnboxed((Class<? extends Enum<?>>) clazz));
+                  Arrays.stream(FAILURES)
+                      .flatMap(
+                          clazz -> Arrays.stream(clazz.getDeclaredClasses()).filter(Class::isEnum))
+                      .forEach(
+                          clazz -> inspector.assertNotUnboxed((Class<? extends Enum<?>>) clazz));
+                })
             .noMinification()
             .enableNoVerticalClassMergingAnnotations()
             .enableInliningAnnotations()
             .enableNeverClassInliningAnnotations()
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile();
     for (Class<?> failure : FAILURES) {
-      testClass(compile, failure, true);
+      testClass(compile, failure);
     }
     for (Class<?> success : SUCCESSES) {
-      testClass(compile, success, false);
+      testClass(compile, success);
     }
   }
 
-  private void testClass(R8TestCompileResult compile, Class<?> testClass, boolean failure)
-      throws Exception {
-    R8TestRunResult run =
-        compile
-            .inspectDiagnosticMessages(
-                m -> {
-                  for (Class<?> declaredClass : testClass.getDeclaredClasses()) {
-                    if (declaredClass.isEnum()) {
-                      if (failure) {
-                        assertEnumIsBoxed(declaredClass, testClass.getSimpleName(), m);
-                      } else {
-                        assertEnumIsUnboxed(declaredClass, testClass.getSimpleName(), m);
-                      }
-                    }
-                  }
-                })
-            .run(parameters.getRuntime(), testClass)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+  private void testClass(R8TestCompileResult compile, Class<?> testClass) throws Exception {
+    compile
+        .run(parameters.getRuntime(), testClass)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   static class SuccessEmptyInterface {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/JavaCGeneratedMethodTest.java b/src/test/java/com/android/tools/r8/enumunboxing/JavaCGeneratedMethodTest.java
index 5d4501f..aaf0239 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/JavaCGeneratedMethodTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/JavaCGeneratedMethodTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.enumunboxing;
 
 import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -15,7 +14,7 @@
 @RunWith(Parameterized.class)
 public class JavaCGeneratedMethodTest extends EnumUnboxingTestBase {
 
-  private static final Class<?> ENUM_CLASS = MyEnum.class;
+  private static final Class<MyEnum> ENUM_CLASS = MyEnum.class;
 
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
@@ -36,23 +35,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> classToTest = Ordinal.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(classToTest, ENUM_CLASS)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .addOptionsModification(
-                opt -> opt.testing.enumUnboxingRewriteJavaCGeneratedMethod = true)
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m))
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(classToTest, ENUM_CLASS)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(ENUM_CLASS))
+        .enableNeverClassInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .addOptionsModification(opt -> opt.testing.enumUnboxingRewriteJavaCGeneratedMethod = true)
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/LambdaEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/LambdaEnumUnboxingTest.java
index d6eb6d1..aba1bb8 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/LambdaEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/LambdaEnumUnboxingTest.java
@@ -51,7 +51,6 @@
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-        .addOptionsModification(options -> options.testing.enableEnumUnboxingDebugLogs = false)
         .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class))
         .setMinApi(parameters.getApiLevel())
         .compile()
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/LargeEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/LargeEnumUnboxingTest.java
index 66c861a..ca48de2 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/LargeEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/LargeEnumUnboxingTest.java
@@ -97,13 +97,11 @@
         .addProgramClasses(mainClass, LargeEnum.class)
         .addKeepMainRule(mainClass)
         .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(LargeEnum.class))
         .enableNeverClassInliningAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-        .allowDiagnosticInfoMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
-        .inspectDiagnosticMessages(
-            m -> assertEnumIsUnboxed(LargeEnum.class, mainClass.getSimpleName(), m))
         .run(parameters.getRuntime(), mainClass)
         .assertSuccessWithOutput(EXPECTED_RESULT);
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/NullCheckEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/NullCheckEnumUnboxingTest.java
index 0f313cf..e8cc088 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/NullCheckEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/NullCheckEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import java.util.Objects;
@@ -36,28 +35,24 @@
 
   @Test
   public void testEnumUnboxing() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(NullCheckEnumUnboxingTest.class)
-            .addKeepMainRule(MainNullTest.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> {
-                  assertEnumIsUnboxed(MyEnum.class, MyEnum.class.getSimpleName(), m);
-                  // MyEnum19 is always unboxed. If minAPI > 19 the unboxer will identify
-                  // Objects#requiredNonNull usage. For 19 and prior, the backport code should not
-                  // prohibit the unboxing either.
-                  assertEnumIsUnboxed(MyEnum19.class, MyEnum19.class.getSimpleName(), m);
-                })
-            .run(parameters.getRuntime(), MainNullTest.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(NullCheckEnumUnboxingTest.class)
+        .addKeepMainRule(MainNullTest.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        // MyEnum19 is always unboxed. If minAPI > 19 the unboxer will identify
+        // Objects#requiredNonNull usage. For 19 and prior, the backport code should not
+        // prohibit the unboxing either.
+        .addEnumUnboxingInspector(
+            inspector -> inspector.assertUnboxed(MyEnum.class, MyEnum19.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .allowDiagnosticMessages()
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), MainNullTest.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/NullOutValueInvokeEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/NullOutValueInvokeEnumUnboxingTest.java
index 8e15ad1..80eb9ab 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/NullOutValueInvokeEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/NullOutValueInvokeEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -17,7 +16,7 @@
 @RunWith(Parameterized.class)
 public class NullOutValueInvokeEnumUnboxingTest extends EnumUnboxingTestBase {
 
-  private static final Class<?> ENUM_CLASS = MyEnum.class;
+  private static final Class<MyEnum> ENUM_CLASS = MyEnum.class;
 
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
@@ -38,22 +37,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> classToTest = NullOutValueInvoke.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(classToTest, ENUM_CLASS)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m))
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(classToTest, ENUM_CLASS)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(ENUM_CLASS))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java
index 1946116..49b4f76 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/OrdinalHashCodeEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -17,7 +16,7 @@
 @RunWith(Parameterized.class)
 public class OrdinalHashCodeEnumUnboxingTest extends EnumUnboxingTestBase {
 
-  private static final Class<?> ENUM_CLASS = MyEnum.class;
+  private static final Class<MyEnum> ENUM_CLASS = MyEnum.class;
 
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
@@ -38,22 +37,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> classToTest = OrdinalHashCode.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(classToTest, ENUM_CLASS)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m))
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(classToTest, ENUM_CLASS)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(ENUM_CLASS))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/OverloadingEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/OverloadingEnumUnboxingTest.java
index bf038fa..5df98f1 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/OverloadingEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/OverloadingEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -36,25 +35,20 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> classToTest = TestClass.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(OverloadingEnumUnboxingTest.class)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> {
-                  assertEnumIsUnboxed(MyEnum1.class, MyEnum1.class.getSimpleName(), m);
-                  assertEnumIsUnboxed(MyEnum2.class, MyEnum2.class.getSimpleName(), m);
-                })
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(OverloadingEnumUnboxingTest.class)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(
+            inspector -> inspector.assertUnboxed(MyEnum1.class, MyEnum2.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @SuppressWarnings("SameParameterValue")
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingTest.java
index d2851c1..536d066 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/PhiEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -35,22 +34,19 @@
 
   @Test
   public void testEnumUnboxing() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(Phi.class, MyEnum.class)
-            .addKeepMainRule(Phi.class)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableInliningAnnotations()
-            .enableNeverClassInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(MyEnum.class, Phi.class.getSimpleName(), m))
-            .run(parameters.getRuntime(), Phi.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Phi.class, MyEnum.class)
+        .addKeepMainRule(Phi.class)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class))
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), Phi.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/PinnedEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/PinnedEnumUnboxingTest.java
index 1c34891..7431727 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/PinnedEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/PinnedEnumUnboxingTest.java
@@ -7,6 +7,8 @@
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.enumunboxing.PinnedEnumUnboxingTest.MainWithKeptEnum.MyEnum;
+import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -40,18 +42,20 @@
         testForR8(parameters.getBackend())
             .addInnerClasses(PinnedEnumUnboxingTest.class)
             .addKeepMainRules(BOXED)
-            .addKeepClassRules(MainWithKeptEnum.MyEnum.class)
+            .addKeepClassRules(MyEnum.class)
             .addKeepMethodRules(MainWithKeptEnumArray.class, "keptMethod()")
             .addKeepRules(enumKeepRules.getKeepRules())
+            .addEnumUnboxingInspector(
+                inspector ->
+                    Arrays.stream(BOXED)
+                        .map(clazz -> (Class<? extends Enum<?>>) clazz.getDeclaredClasses()[0])
+                        .forEach(inspector::assertNotUnboxed))
             .enableNeverClassInliningAnnotations()
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile();
     for (Class<?> boxed : BOXED) {
       compileResult
-          .inspectDiagnosticMessages(
-              m -> assertEnumIsBoxed(boxed.getDeclaredClasses()[0], boxed.getSimpleName(), m))
           .run(parameters.getRuntime(), boxed)
           .assertSuccessWithOutputLines("0");
     }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/StaticMethodsEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/StaticMethodsEnumUnboxingTest.java
index 390fe18..43be887 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/StaticMethodsEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/StaticMethodsEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -36,25 +35,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> classToTest = StaticMethods.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(StaticMethodsEnumUnboxingTest.class)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> {
-                  assertEnumIsUnboxed(MyEnum.class, classToTest.getSimpleName(), m);
-                  assertEnumIsUnboxed(MyEnum2.class, classToTest.getSimpleName(), m);
-                })
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(StaticMethodsEnumUnboxingTest.class)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class, MyEnum2.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @SuppressWarnings("SameParameterValue")
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/StringValueOfEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/StringValueOfEnumUnboxingTest.java
index 1ab86b3..904fc48f 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/StringValueOfEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/StringValueOfEnumUnboxingTest.java
@@ -5,7 +5,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -34,22 +33,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> classToTest = Main.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addProgramClasses(classToTest, MyEnum.class)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(MyEnum.class, classToTest.getSimpleName(), m))
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addProgramClasses(classToTest, MyEnum.class)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @NeverClassInline
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
index f58a069..43dec5d 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/SwitchEnumUnboxingTest.java
@@ -9,7 +9,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -22,7 +21,7 @@
 @RunWith(Parameterized.class)
 public class SwitchEnumUnboxingTest extends EnumUnboxingTestBase {
 
-  private static final Class<?> ENUM_CLASS = MyEnumFewCases.class;
+  private static final Class<MyEnumFewCases> ENUM_CLASS = MyEnumFewCases.class;
 
   private final TestParameters parameters;
   private final boolean enumValueOptimization;
@@ -43,24 +42,21 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<Switch> classToTest = Switch.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(SwitchEnumUnboxingTest.class)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableInliningAnnotations()
-            .enableNeverClassInliningAnnotations()
-            .noMinification() // For assertions.
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspect(this::assertSwitchPresentButSwitchMapRemoved)
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(ENUM_CLASS, classToTest.getSimpleName(), m))
-            .run(parameters.getRuntime(), classToTest)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(SwitchEnumUnboxingTest.class)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(ENUM_CLASS))
+        .enableInliningAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .noMinification() // For assertions.
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::assertSwitchPresentButSwitchMapRemoved)
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   private void assertSwitchPresentButSwitchMapRemoved(CodeInspector i) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ToStringEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ToStringEnumUnboxingTest.java
index 50a4d58..99e4e25 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ToStringEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ToStringEnumUnboxingTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.enumunboxing;
 
 import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -35,23 +34,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> success = EnumNameToString.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ToStringEnumUnboxingTest.class)
-            .addKeepMainRule(EnumNameToString.class)
-            .enableNeverClassInliningAnnotations()
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m ->
-                    assertEnumIsUnboxed(
-                        success.getDeclaredClasses()[0], success.getSimpleName(), m))
-            .run(parameters.getRuntime(), success)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(ToStringEnumUnboxingTest.class)
+        .addKeepMainRule(EnumNameToString.class)
+        .addEnumUnboxingInspector(
+            inspector -> inspector.assertUnboxed(EnumNameToString.MyEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), success)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   static class EnumNameToString {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ToStringOverrideEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ToStringOverrideEnumUnboxingTest.java
index 8b9b546..d8d115c 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ToStringOverrideEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ToStringOverrideEnumUnboxingTest.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.enumunboxing;
 
 import com.android.tools.r8.NeverClassInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -35,21 +34,19 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> success = EnumNameToString.class;
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(ToStringOverrideEnumUnboxingTest.class)
-            .addKeepMainRule(EnumNameToString.class)
-            .enableNeverClassInliningAnnotations()
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsBoxed(success.getDeclaredClasses()[0], success.getSimpleName(), m))
-            .run(parameters.getRuntime(), success)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(ToStringOverrideEnumUnboxingTest.class)
+        .addKeepMainRule(EnumNameToString.class)
+        .enableNeverClassInliningAnnotations()
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .addEnumUnboxingInspector(
+            inspector -> inspector.assertNotUnboxed(EnumNameToString.MyEnum.class))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), success)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   static class EnumNameToString {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java
index a6b7027..6a35396 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/UnusedCaseEnumUnboxingTest.java
@@ -6,7 +6,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.util.List;
@@ -34,23 +33,20 @@
 
   @Test
   public void testEnumUnboxing() throws Exception {
-    R8TestRunResult run =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(UnusedCaseEnumUnboxingTest.class)
-            .addKeepMainRule(Main.class)
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspect(this::assertFieldsRemoved)
-            .inspectDiagnosticMessages(
-                m -> assertEnumIsUnboxed(MyEnum.class, Main.class.getSimpleName(), m))
-            .run(parameters.getRuntime(), Main.class)
-            .assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(UnusedCaseEnumUnboxingTest.class)
+        .addKeepMainRule(Main.class)
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .inspect(this::assertFieldsRemoved)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   private void assertFieldsRemoved(CodeInspector codeInspector) {
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingFailureTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingFailureTest.java
index 1da8c62..15bdcb7 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingFailureTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingFailureTest.java
@@ -36,14 +36,12 @@
     testForR8(parameters.getBackend())
         .addInnerClasses(ValueOfEnumUnboxingFailureTest.class)
         .addKeepMainRule(success)
+        .addEnumUnboxingInspector(inspector -> inspector.assertNotUnboxed(Main.Enum.class))
         .enableNeverClassInliningAnnotations()
         .addKeepRules(enumKeepRules.getKeepRules())
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-        .allowDiagnosticInfoMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
-        .inspectDiagnosticMessages(
-            m -> assertEnumIsBoxed(success.getDeclaredClasses()[0], success.getSimpleName(), m))
         .run(parameters.getRuntime(), success)
         .assertSuccessWithOutput("VALUE1");
   }
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingTest.java
index 23293f5..794cfab 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/ValueOfEnumUnboxingTest.java
@@ -6,8 +6,8 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
+import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -43,22 +43,21 @@
         testForR8(parameters.getBackend())
             .addInnerClasses(ValueOfEnumUnboxingTest.class)
             .addKeepMainRules(SUCCESSES)
+            .addEnumUnboxingInspector(
+                inspector ->
+                    Arrays.stream(SUCCESSES)
+                        .map(clazz -> (Class<? extends Enum<?>>) clazz.getDeclaredClasses()[0])
+                        .forEach(inspector::assertUnboxed))
             .enableNeverClassInliningAnnotations()
             .addKeepRules(enumKeepRules.getKeepRules())
             .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
             .setMinApi(parameters.getApiLevel())
             .compile();
     for (Class<?> success : SUCCESSES) {
-      R8TestRunResult run =
-          compile
-              .inspectDiagnosticMessages(
-                  m ->
-                      assertEnumIsUnboxed(
-                          success.getDeclaredClasses()[0], success.getSimpleName(), m))
-              .run(parameters.getRuntime(), success)
-              .assertSuccess();
-      assertLines2By2Correct(run.getStdOut());
+      compile
+          .run(parameters.getRuntime(), success)
+          .assertSuccess()
+          .inspectStdOut(this::assertLines2By2Correct);
     }
   }
 
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodOverrideEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodOverrideEnumUnboxingTest.java
index 6020f1a..4c69310 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodOverrideEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodOverrideEnumUnboxingTest.java
@@ -49,7 +49,6 @@
         .enableNeverClassInliningAnnotations()
         .enableNoVerticalClassMergingAnnotations()
         .addOptionsModification(options -> enableEnumOptions(options, enumValueOptimization))
-        .addOptionsModification(options -> options.testing.enableEnumUnboxingDebugLogs = false)
         .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(MyEnum.class))
         .setMinApi(parameters.getApiLevel())
         .compile()
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsAccessibilityErrorEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsAccessibilityErrorEnumUnboxingTest.java
index 52d8688..03e6de9 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsAccessibilityErrorEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsAccessibilityErrorEnumUnboxingTest.java
@@ -67,7 +67,6 @@
         .enableNeverClassInliningAnnotations()
         .enableInliningAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-        .allowDiagnosticInfoMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
         .run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java
index 3a1fbab..c24a4d9 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/VirtualMethodsEnumUnboxingTest.java
@@ -5,8 +5,6 @@
 
 import com.android.tools.r8.NeverClassInline;
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestCompileResult;
-import com.android.tools.r8.R8TestRunResult;
 import com.android.tools.r8.TestParameters;
 import java.util.List;
 import org.junit.Test;
@@ -35,33 +33,28 @@
   @Test
   public void testEnumUnboxing() throws Exception {
     Class<?> classToTest = VirtualMethods.class;
-    R8TestCompileResult compile =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(VirtualMethodsEnumUnboxingTest.class)
-            .addKeepMainRule(classToTest)
-            .addKeepRules(enumKeepRules.getKeepRules())
-            .enableNeverClassInliningAnnotations()
-            .enableInliningAnnotations()
-            .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
-            .allowDiagnosticInfoMessages()
-            .setMinApi(parameters.getApiLevel())
-            .compile()
-            .inspectDiagnosticMessages(
-                m -> {
-                  assertEnumIsUnboxed(MyEnum.class, classToTest.getSimpleName(), m);
-                  assertEnumIsUnboxed(MyEnum2.class, classToTest.getSimpleName(), m);
-                  assertEnumIsUnboxed(MyEnumWithCollisions.class, classToTest.getSimpleName(), m);
-                  assertEnumIsUnboxed(
-                      MyEnumWithPackagePrivateCall.class, classToTest.getSimpleName(), m);
-                  assertEnumIsUnboxed(
-                      MyEnumWithProtectedCall.class, classToTest.getSimpleName(), m);
-                  assertEnumIsUnboxed(
-                      MyEnumWithPackagePrivateFieldAccess.class, classToTest.getSimpleName(), m);
-                  assertEnumIsUnboxed(
-                      MyEnumWithPackagePrivateAndPrivateCall.class, classToTest.getSimpleName(), m);
-                });
-    R8TestRunResult run = compile.run(parameters.getRuntime(), classToTest).assertSuccess();
-    assertLines2By2Correct(run.getStdOut());
+    testForR8(parameters.getBackend())
+        .addInnerClasses(VirtualMethodsEnumUnboxingTest.class)
+        .addKeepMainRule(classToTest)
+        .addKeepRules(enumKeepRules.getKeepRules())
+        .addEnumUnboxingInspector(
+            inspector ->
+                inspector.assertUnboxed(
+                    MyEnum.class,
+                    MyEnum2.class,
+                    MyEnumWithCollisions.class,
+                    MyEnumWithPackagePrivateCall.class,
+                    MyEnumWithProtectedCall.class,
+                    MyEnumWithPackagePrivateFieldAccess.class,
+                    MyEnumWithPackagePrivateAndPrivateCall.class))
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .setMinApi(parameters.getApiLevel())
+        .compile()
+        .run(parameters.getRuntime(), classToTest)
+        .assertSuccess()
+        .inspectStdOut(this::assertLines2By2Correct);
   }
 
   @SuppressWarnings("SameParameterValue")
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
index 6f4b565..2d89396 100644
--- a/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/enumunboxing/kotlin/SimpleKotlinEnumUnboxingTest.java
@@ -71,19 +71,17 @@
         .addKeepRules(enumKeepRules.getKeepRules())
         .addKeepRuntimeVisibleAnnotations()
         .addOptionsModification(opt -> enableEnumOptions(opt, enumValueOptimization))
+        .addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(PKG + ".Color"))
         .allowDiagnosticMessages()
         .setMinApi(parameters.getApiLevel())
         .compile()
         .inspectDiagnosticMessages(
-            messages -> {
-              messages
-                  .assertNoErrors()
-                  .assertAllWarningsMatch(
-                      diagnosticMessage(
-                          containsString("Resource 'META-INF/MANIFEST.MF' already exists.")));
-              assertEnumIsUnboxed(
-                  PKG + ".Color", SimpleKotlinEnumUnboxingTest.class.getSimpleName(), messages);
-            })
+            messages ->
+                messages
+                    .assertNoErrors()
+                    .assertAllWarningsMatch(
+                        diagnosticMessage(
+                            containsString("Resource 'META-INF/MANIFEST.MF' already exists."))))
         .run(parameters.getRuntime(), PKG + ".MainKt")
         .assertSuccessWithOutputLines("RED", "GREEN", "BLUE");
   }
diff --git a/src/test/java/com/android/tools/r8/internal/YouTubeV1533TreeShakeJarVerificationTest.java b/src/test/java/com/android/tools/r8/internal/YouTubeV1533TreeShakeJarVerificationTest.java
index 88c7692..8bb7f4c 100644
--- a/src/test/java/com/android/tools/r8/internal/YouTubeV1533TreeShakeJarVerificationTest.java
+++ b/src/test/java/com/android/tools/r8/internal/YouTubeV1533TreeShakeJarVerificationTest.java
@@ -3,10 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.internal;
 
-import static com.android.tools.r8.ToolHelper.isLocalDevelopment;
-import static com.android.tools.r8.ToolHelper.shouldRunSlowTests;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestParameters;
@@ -41,8 +38,8 @@
   @Test
   public void testR8() throws Exception {
     // TODO(b/141603168): Enable this on the bots.
-    assumeTrue(isLocalDevelopment());
-    assumeTrue(shouldRunSlowTests());
+    // assumeTrue(isLocalDevelopment());
+    // assumeTrue(shouldRunSlowTests());
 
     LibrarySanitizer librarySanitizer =
         new LibrarySanitizer(temp)
@@ -57,7 +54,10 @@
             .addLibraryFiles(librarySanitizer.getSanitizedLibrary())
             .addKeepRuleFiles(getKeepRuleFiles())
             .addMainDexRuleFiles(getMainDexRuleFiles())
+            .addIgnoreWarnings()
             .allowDiagnosticMessages()
+            .allowStdoutMessages()
+            .allowUnusedDontWarnPatterns()
             .allowUnusedProguardConfigurationRules()
             .setMinApi(AndroidApiLevel.H_MR2)
             .compile();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java
index 38f7e92..d554d50 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/EnumUnboxingInspector.java
@@ -10,6 +10,7 @@
 
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.ir.optimize.enums.EnumDataMap;
+import com.android.tools.r8.utils.DescriptorUtils;
 
 public class EnumUnboxingInspector {
 
@@ -21,8 +22,23 @@
     this.unboxedEnums = unboxedEnums;
   }
 
+  public EnumUnboxingInspector assertUnboxed(String typeName) {
+    assertTrue(
+        unboxedEnums.isUnboxedEnum(
+            dexItemFactory.createType(DescriptorUtils.javaTypeToDescriptor(typeName))));
+    return this;
+  }
+
   public EnumUnboxingInspector assertUnboxed(Class<? extends Enum<?>> clazz) {
-    assertTrue(unboxedEnums.isUnboxedEnum(toDexType(clazz, dexItemFactory)));
+    assertTrue(clazz.getTypeName(), unboxedEnums.isUnboxedEnum(toDexType(clazz, dexItemFactory)));
+    return this;
+  }
+
+  @SafeVarargs
+  public final EnumUnboxingInspector assertUnboxed(Class<? extends Enum<?>>... classes) {
+    for (Class<? extends Enum<?>> clazz : classes) {
+      assertUnboxed(clazz);
+    }
     return this;
   }
 
@@ -36,15 +52,24 @@
   }
 
   @SafeVarargs
-  public final EnumUnboxingInspector assertUnboxed(Class<? extends Enum<?>>... classes) {
+  public final EnumUnboxingInspector assertUnboxedIf(
+      boolean condition, Class<? extends Enum<?>>... classes) {
     for (Class<? extends Enum<?>> clazz : classes) {
-      assertUnboxed(clazz);
+      assertUnboxedIf(condition, clazz);
     }
     return this;
   }
 
   public EnumUnboxingInspector assertNotUnboxed(Class<? extends Enum<?>> clazz) {
-    assertFalse(unboxedEnums.isUnboxedEnum(toDexType(clazz, dexItemFactory)));
+    assertFalse(clazz.getTypeName(), unboxedEnums.isUnboxedEnum(toDexType(clazz, dexItemFactory)));
+    return this;
+  }
+
+  @SafeVarargs
+  public final EnumUnboxingInspector assertNotUnboxed(Class<? extends Enum<?>>... classes) {
+    for (Class<? extends Enum<?>> clazz : classes) {
+      assertNotUnboxed(clazz);
+    }
     return this;
   }
 }