Migrate compat tests to new test builders.

Change-Id: I07e37f40c8a68f5d9b0c80dfe3188c0b44656734
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
index 2ac7880..48c6dea 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
@@ -11,23 +11,23 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
 
-import com.android.tools.r8.CompatProguardCommandBuilder;
 import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.R8Command;
+import com.android.tools.r8.R8TestCompileResult;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.graph.invokesuper.Consumer;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
-import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.shaking.CollectingGraphConsumer;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.shaking.forceproguardcompatibility.TestMain.MentionedClass;
 import com.android.tools.r8.shaking.forceproguardcompatibility.defaultmethods.ClassImplementingInterface;
 import com.android.tools.r8.shaking.forceproguardcompatibility.defaultmethods.InterfaceWithDefaultMethods;
 import com.android.tools.r8.shaking.forceproguardcompatibility.defaultmethods.TestClass;
 import com.android.tools.r8.shaking.forceproguardcompatibility.keepattributes.TestKeepAttributes;
 import com.android.tools.r8.utils.AndroidApiLevel;
-import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -43,77 +43,79 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
 @RunWith(Parameterized.class)
 public class ForceProguardCompatibilityTest extends TestBase {
 
-  private Backend backend;
+  private final TestParameters parameters;
+  private final boolean forceProguardCompatibility;
 
-  @Parameterized.Parameters(name = "Backend: {0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  @Parameters(name = "{0}, compat:{1}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters()
+            .withAllRuntimes()
+            .withApiLevelsStartingAtIncluding(AndroidApiLevel.O)
+            .build(),
+        BooleanUtils.values());
   }
 
-  public ForceProguardCompatibilityTest(Backend backend) {
-    this.backend = backend;
+  public ForceProguardCompatibilityTest(
+      TestParameters parameters, boolean forceProguardCompatibility) {
+    this.parameters = parameters;
+    this.forceProguardCompatibility = forceProguardCompatibility;
   }
 
-  private void test(Class mainClass, Class mentionedClass, boolean forceProguardCompatibility)
-      throws Exception {
-    String proguardConfig = keepMainProguardConfiguration(mainClass, true, false);
+  private void test(Class mainClass, Class mentionedClass) throws Exception {
     CodeInspector inspector =
-        new CodeInspector(
-            compileWithR8(
-                readClasses(ImmutableList.of(mainClass, mentionedClass)),
-                proguardConfig,
-                options -> options.forceProguardCompatibility = forceProguardCompatibility,
-                backend));
-    assertTrue(inspector.clazz(mainClass.getCanonicalName()).isPresent());
-    ClassSubject clazz = inspector.clazz(getJavacGeneratedClassName(mentionedClass));
-    assertTrue(clazz.isPresent());
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .noMinification()
+            .allowAccessModification()
+            .addProgramClasses(mainClass, mentionedClass)
+            .addKeepMainRule(mainClass)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspector();
+    assertThat(inspector.clazz(mainClass), isPresent());
+    ClassSubject clazz = inspector.clazz(mentionedClass);
+    assertThat(clazz, isPresent());
     MethodSubject defaultInitializer = clazz.method(MethodSignature.initializer(new String[]{}));
     assertEquals(forceProguardCompatibility, defaultInitializer.isPresent());
   }
 
   @Test
   public void testKeepDefaultInitializer() throws Exception {
-    test(TestMain.class, TestMain.MentionedClass.class, true);
-    test(TestMain.class, TestMain.MentionedClass.class, false);
+    test(TestMain.class, TestMain.MentionedClass.class);
   }
 
   @Test
   public void testKeepDefaultInitializerArrayType() throws Exception {
-    test(TestMainArrayType.class, TestMainArrayType.MentionedClass.class, true);
-    test(TestMainArrayType.class, TestMainArrayType.MentionedClass.class, false);
+    test(TestMainArrayType.class, TestMainArrayType.MentionedClass.class);
   }
 
-  private void runAnnotationsTest(boolean forceProguardCompatibility, boolean keepAnnotations)
-      throws Exception {
-    R8Command.Builder builder = new CompatProguardCommandBuilder(forceProguardCompatibility);
+  private void runAnnotationsTest(boolean keepAnnotations) throws Exception {
     // Add application classes including the annotation class.
     Class mainClass = TestMain.class;
     Class mentionedClassWithAnnotations = TestMain.MentionedClassWithAnnotation.class;
     Class annotationClass = TestAnnotation.class;
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(mainClass));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(TestMain.MentionedClass.class));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(mentionedClassWithAnnotations));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(annotationClass));
-    // Keep main class and the annotation class.
-    builder.addProguardConfiguration(
-        ImmutableList.of(keepMainProguardConfiguration(mainClass, true, false)), Origin.unknown());
-    builder.addProguardConfiguration(
-        ImmutableList.of("-keep class " + annotationClass.getCanonicalName() + " { *; }"),
-        Origin.unknown());
-    if (keepAnnotations) {
-      builder.addProguardConfiguration(ImmutableList.of("-keepattributes *Annotation*"),
-          Origin.unknown());
-    }
 
-    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
-    CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
-    assertTrue(inspector.clazz(mainClass.getCanonicalName()).isPresent());
-    ClassSubject clazz = inspector.clazz(getJavacGeneratedClassName(mentionedClassWithAnnotations));
-    assertTrue(clazz.isPresent());
+    CodeInspector inspector =
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .addProgramClasses(
+                mainClass, MentionedClass.class, mentionedClassWithAnnotations, annotationClass)
+            .addKeepMainRule(mainClass)
+            .allowAccessModification()
+            .noMinification()
+            .addKeepClassAndMembersRules(annotationClass)
+            .map(b -> keepAnnotations ? b.addKeepAttributes("*Annotation*") : b)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspector();
+
+    assertThat(inspector.clazz(mainClass), isPresent());
+    ClassSubject clazz = inspector.clazz(mentionedClassWithAnnotations);
+    assertThat(clazz, isPresent());
 
     // The test contains only a member class so the enclosing-method attribute will be null.
     assertEquals(
@@ -125,30 +127,27 @@
 
   @Test
   public void testAnnotations() throws Exception {
-    runAnnotationsTest(true, true);
-    runAnnotationsTest(true, false);
-    runAnnotationsTest(false, true);
-    runAnnotationsTest(false, false);
+    runAnnotationsTest(true);
+    runAnnotationsTest(false);
   }
 
-  private void runDefaultConstructorTest(boolean forceProguardCompatibility,
-      Class<?> testClass, boolean hasDefaultConstructor) throws Exception {
-    CompatProguardCommandBuilder builder =
-        new CompatProguardCommandBuilder(forceProguardCompatibility);
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(testClass));
+  private void runDefaultConstructorTest(Class<?> testClass, boolean hasDefaultConstructor)
+      throws Exception {
+
     List<String> proguardConfig = ImmutableList.of(
         "-keep class " + testClass.getCanonicalName() + " {",
         "  public void method();",
         "}");
-    builder.addProguardConfiguration(proguardConfig, Origin.unknown());
-
-    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
-
-    CollectingGraphConsumer graphConsumer = new CollectingGraphConsumer(null);
-    builder.setKeptGraphConsumer(graphConsumer);
 
     GraphInspector inspector =
-        new GraphInspector(graphConsumer, new CodeInspector(ToolHelper.runR8(builder.build())));
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .addProgramClasses(testClass)
+            .addKeepRules(proguardConfig)
+            .enableGraphInspector()
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .graphInspector();
+
     QueryNode clazzNode = inspector.clazz(classFromClass(testClass)).assertPresent();
     if (hasDefaultConstructor) {
       QueryNode initNode = inspector.method(methodFromMethod(testClass.getConstructor()));
@@ -171,29 +170,28 @@
 
   @Test
   public void testDefaultConstructor() throws Exception {
-    runDefaultConstructorTest(true, TestClassWithDefaultConstructor.class, true);
-    runDefaultConstructorTest(true, TestClassWithoutDefaultConstructor.class, false);
-    runDefaultConstructorTest(false, TestClassWithDefaultConstructor.class, true);
-    runDefaultConstructorTest(false, TestClassWithoutDefaultConstructor.class, false);
+    runDefaultConstructorTest(TestClassWithDefaultConstructor.class, true);
+    runDefaultConstructorTest(TestClassWithoutDefaultConstructor.class, false);
   }
 
-  public void testCheckCast(boolean forceProguardCompatibility, Class mainClass,
-      Class instantiatedClass, boolean containsCheckCast)
+  public void testCheckCast(Class mainClass, Class instantiatedClass, boolean containsCheckCast)
       throws Exception {
-    R8Command.Builder builder = new CompatProguardCommandBuilder(forceProguardCompatibility);
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(mainClass));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(instantiatedClass));
     List<String> proguardConfig = ImmutableList.of(
         "-keep class " + mainClass.getCanonicalName() + " {",
         "  public static void main(java.lang.String[]);",
         "}",
         "-dontobfuscate");
-    builder.addProguardConfiguration(proguardConfig, Origin.unknown());
 
-    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
-    CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
-    assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
-    ClassSubject clazz = inspector.clazz(getJavacGeneratedClassName(instantiatedClass));
+    CodeInspector inspector =
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .addProgramClasses(mainClass, instantiatedClass)
+            .addKeepRules(proguardConfig)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspector();
+
+    assertTrue(inspector.clazz(mainClass).isPresent());
+    ClassSubject clazz = inspector.clazz(instantiatedClass);
     assertEquals(containsCheckCast, clazz.isPresent());
     assertEquals(containsCheckCast, clazz.isPresent());
     if (clazz.isPresent()) {
@@ -215,26 +213,15 @@
 
   @Test
   public void checkCastTest() throws Exception {
-    testCheckCast(true, TestMainWithCheckCast.class, TestClassWithDefaultConstructor.class, true);
-    testCheckCast(
-        true, TestMainWithoutCheckCast.class, TestClassWithDefaultConstructor.class, false);
-    testCheckCast(
-        false, TestMainWithCheckCast.class, TestClassWithDefaultConstructor.class, true);
-    testCheckCast(
-        false, TestMainWithoutCheckCast.class, TestClassWithDefaultConstructor.class, false);
+    testCheckCast(TestMainWithCheckCast.class, TestClassWithDefaultConstructor.class, true);
+    testCheckCast(TestMainWithoutCheckCast.class, TestClassWithDefaultConstructor.class, false);
   }
 
-  public void testClassForName(
-      boolean forceProguardCompatibility, boolean allowObfuscation) throws Exception {
-    CompatProguardCommandBuilder builder =
-        new CompatProguardCommandBuilder(forceProguardCompatibility);
+  public void testClassForName(boolean allowObfuscation) throws Exception {
     Class mainClass = TestMainWithClassForName.class;
     Class forNameClass1 = TestClassWithDefaultConstructor.class;
     Class forNameClass2 = TestClassWithoutDefaultConstructor.class;
     List<Class> forNameClasses = ImmutableList.of(forNameClass1, forNameClass2);
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(mainClass));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(forNameClass1));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(forNameClass2));
     ImmutableList.Builder<String> proguardConfigurationBuilder = ImmutableList.builder();
     proguardConfigurationBuilder.add(
         "-keep class " + mainClass.getCanonicalName() + " {",
@@ -245,19 +232,22 @@
       proguardConfigurationBuilder.add("-dontobfuscate");
     }
     List<String> proguardConfig = proguardConfigurationBuilder.build();
-    builder.addProguardConfiguration(proguardConfig, Origin.unknown());
-    if (allowObfuscation) {
-      builder.setProguardMapOutputPath(temp.newFile().toPath());
-    }
 
-    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
-    CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
-    assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
-    forNameClasses.forEach(clazz -> {
-      ClassSubject subject = inspector.clazz(getJavacGeneratedClassName(clazz));
-      assertTrue(subject.isPresent());
-      assertEquals(subject.isPresent() && allowObfuscation, subject.isRenamed());
-    });
+    CodeInspector inspector =
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .addProgramClasses(mainClass, forNameClass1, forNameClass2)
+            .addKeepRules(proguardConfig)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspector();
+
+    assertTrue(inspector.clazz(mainClass).isPresent());
+    forNameClasses.forEach(
+        clazz -> {
+          ClassSubject subject = inspector.clazz(clazz);
+          assertTrue(subject.isPresent());
+          assertEquals(allowObfuscation, subject.isRenamed());
+        });
 
     if (isRunProguard()) {
       Path proguardedJar = File.createTempFile("proguarded", ".jar", temp.getRoot()).toPath();
@@ -279,20 +269,14 @@
 
   @Test
   public void classForNameTest() throws Exception {
-    testClassForName(true, false);
-    testClassForName(false, false);
-    testClassForName(true, true);
-    testClassForName(false, true);
+    testClassForName(true);
+    testClassForName(false);
   }
 
-  public void testClassGetMembers(
-      boolean forceProguardCompatibility, boolean allowObfuscation) throws Exception {
-    CompatProguardCommandBuilder builder =
-        new CompatProguardCommandBuilder(forceProguardCompatibility);
+  public void testClassGetMembers(boolean allowObfuscation) throws Exception {
     Class mainClass = TestMainWithGetMembers.class;
     Class withMemberClass = TestClassWithMembers.class;
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(mainClass));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(withMemberClass));
+
     ImmutableList.Builder<String> proguardConfigurationBuilder = ImmutableList.builder();
     proguardConfigurationBuilder.add(
         "-keep class " + mainClass.getCanonicalName() + " {",
@@ -303,25 +287,27 @@
       proguardConfigurationBuilder.add("-dontobfuscate");
     }
     List<String> proguardConfig = proguardConfigurationBuilder.build();
-    builder.addProguardConfiguration(proguardConfig, Origin.unknown());
-    if (allowObfuscation) {
-      builder.setProguardMapOutputPath(temp.newFile().toPath());
-    }
 
-    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
-    CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
-    assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
-    ClassSubject classSubject = inspector.clazz(getJavacGeneratedClassName(withMemberClass));
+    CodeInspector inspector =
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .addProgramClasses(mainClass, withMemberClass)
+            .addKeepRules(proguardConfig)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspector();
+
+    assertTrue(inspector.clazz(mainClass).isPresent());
+    ClassSubject classSubject = inspector.clazz(withMemberClass);
     // Due to the direct usage of .class
     assertTrue(classSubject.isPresent());
     assertEquals(allowObfuscation, classSubject.isRenamed());
     FieldSubject foo = classSubject.field("java.lang.String", "foo");
     assertTrue(foo.isPresent());
-    assertEquals(foo.isPresent() && allowObfuscation, foo.isRenamed());
+    assertEquals(allowObfuscation, foo.isRenamed());
     MethodSubject bar =
         classSubject.method("java.lang.String", "bar", ImmutableList.of("java.lang.String"));
     assertTrue(bar.isPresent());
-    assertEquals(bar.isPresent() && allowObfuscation, bar.isRenamed());
+    assertEquals(allowObfuscation, bar.isRenamed());
 
     if (isRunProguard()) {
       Path proguardedJar = File.createTempFile("proguarded", ".jar", temp.getRoot()).toPath();
@@ -348,20 +334,14 @@
 
   @Test
   public void classGetMembersTest() throws Exception {
-    testClassGetMembers(true, false);
-    testClassGetMembers(false, false);
-    testClassGetMembers(true, true);
-    testClassGetMembers(false, true);
+    testClassGetMembers(true);
+    testClassGetMembers(false);
   }
 
-  public void testAtomicFieldUpdaters(
-      boolean forceProguardCompatibility, boolean allowObfuscation) throws Exception {
-    CompatProguardCommandBuilder builder =
-        new CompatProguardCommandBuilder(forceProguardCompatibility);
+  public void testAtomicFieldUpdaters(boolean allowObfuscation) throws Exception {
     Class mainClass = TestMainWithAtomicFieldUpdater.class;
     Class withVolatileFields = TestClassWithVolatileFields.class;
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(mainClass));
-    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(withVolatileFields));
+
     ImmutableList.Builder<String> proguardConfigurationBuilder = ImmutableList.builder();
     proguardConfigurationBuilder.add(
         "-keep class " + mainClass.getCanonicalName() + " {",
@@ -372,27 +352,29 @@
       proguardConfigurationBuilder.add("-dontobfuscate");
     }
     List<String> proguardConfig = proguardConfigurationBuilder.build();
-    builder.addProguardConfiguration(proguardConfig, Origin.unknown());
-    if (allowObfuscation) {
-      builder.setProguardMapOutputPath(temp.newFile().toPath());
-    }
 
-    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
-    CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
-    assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
-    ClassSubject classSubject = inspector.clazz(getJavacGeneratedClassName(withVolatileFields));
+    CodeInspector inspector =
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .addProgramClasses(mainClass, withVolatileFields)
+            .addKeepRules(proguardConfig)
+            .setMinApi(parameters.getApiLevel())
+            .compile()
+            .inspector();
+
+    assertTrue(inspector.clazz(mainClass).isPresent());
+    ClassSubject classSubject = inspector.clazz(withVolatileFields);
     // Due to the direct usage of .class
     assertTrue(classSubject.isPresent());
     assertEquals(allowObfuscation, classSubject.isRenamed());
     FieldSubject f = classSubject.field("int", "intField");
     assertTrue(f.isPresent());
-    assertEquals(f.isPresent() && allowObfuscation, f.isRenamed());
+    assertEquals(allowObfuscation, f.isRenamed());
     f = classSubject.field("long", "longField");
     assertTrue(f.isPresent());
-    assertEquals(f.isPresent() && allowObfuscation, f.isRenamed());
+    assertEquals(allowObfuscation, f.isRenamed());
     f = classSubject.field("java.lang.Object", "objField");
     assertTrue(f.isPresent());
-    assertEquals(f.isPresent() && allowObfuscation, f.isRenamed());
+    assertEquals(allowObfuscation, f.isRenamed());
 
     if (isRunProguard()) {
       Path proguardedJar = File.createTempFile("proguarded", ".jar", temp.getRoot()).toPath();
@@ -422,15 +404,11 @@
 
   @Test
   public void atomicFieldUpdaterTest() throws Exception {
-    testAtomicFieldUpdaters(true, false);
-    testAtomicFieldUpdaters(false, false);
-    testAtomicFieldUpdaters(true, true);
-    testAtomicFieldUpdaters(false, true);
+    testAtomicFieldUpdaters(true);
+    testAtomicFieldUpdaters(false);
   }
 
-  public void testKeepAttributes(
-      boolean forceProguardCompatibility, boolean innerClasses, boolean enclosingMethod)
-      throws Exception {
+  public void testKeepAttributes(boolean innerClasses, boolean enclosingMethod) throws Exception {
     String keepRules = "";
     if (innerClasses || enclosingMethod) {
       List<String> attributes = new ArrayList<>();
@@ -446,7 +424,7 @@
 
     try {
       inspector =
-          testForR8Compat(backend, forceProguardCompatibility)
+          testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
               .addProgramFiles(
                   ToolHelper.getClassFilesForTestPackage(TestKeepAttributes.class.getPackage()))
               .addKeepRules(
@@ -457,8 +435,8 @@
                   keepRules)
               .addOptionsModification(options -> options.enableClassInlining = false)
               .enableSideEffectAnnotations()
-              .compile()
-              .run(TestKeepAttributes.class)
+              .setMinApi(parameters.getApiLevel())
+              .run(parameters.getRuntime(), TestKeepAttributes.class)
               .assertSuccessWithOutput(innerClasses || enclosingMethod ? "1" : "0")
               .inspector();
     } catch (CompilationFailedException e) {
@@ -477,14 +455,10 @@
 
   @Test
   public void keepAttributesTest() throws Exception {
-    testKeepAttributes(true, false, false);
-    testKeepAttributes(true, true, false);
-    testKeepAttributes(true, false, true);
-    testKeepAttributes(true, true, true);
-    testKeepAttributes(false, false, false);
-    testKeepAttributes(false, true, false);
-    testKeepAttributes(false, false, true);
-    testKeepAttributes(false, true, true);
+    testKeepAttributes(false, false);
+    testKeepAttributes(true, false);
+    testKeepAttributes(false, true);
+    testKeepAttributes(true, true);
   }
 
   private void runKeepDefaultMethodsTest(
@@ -492,38 +466,34 @@
       Consumer<CodeInspector> inspection,
       Consumer<GraphInspector> compatInspection)
       throws Exception {
-    Class mainClass = TestClass.class;
-    CompatProguardCommandBuilder builder = new CompatProguardCommandBuilder();
-    builder.addProgramFiles(ToolHelper.getClassFilesForTestPackage(mainClass.getPackage()));
-    builder.addProguardConfiguration(ImmutableList.of(
-        "-keep class " + mainClass.getCanonicalName() + "{",
-        "  public <init>();",
-        "  public static void main(java.lang.String[]);",
-        "}",
-        "-dontobfuscate"),
-        Origin.unknown());
-    builder.addProguardConfiguration(additionalKeepRules, Origin.unknown());
-    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
-    CollectingGraphConsumer graphConsumer = new CollectingGraphConsumer(null);
-    builder.setKeptGraphConsumer(graphConsumer);
-    if (backend == Backend.DEX) {
-      builder.setMinApiLevel(AndroidApiLevel.O.getLevel());
+    if (parameters.isDexRuntime()) {
+      assert parameters.getApiLevel().getLevel() >= AndroidApiLevel.O.getLevel();
     }
-    AndroidApp app =
-        ToolHelper.runR8(
-            builder.build(),
-            o -> {
-              o.enableClassInlining = false;
 
-              // Prevent InterfaceWithDefaultMethods from being merged into
-              // ClassImplementingInterface.
-              o.enableVerticalClassMerging = false;
-            });
+    Class mainClass = TestClass.class;
+    R8TestCompileResult compileResult =
+        testForR8Compat(parameters.getBackend(), forceProguardCompatibility)
+            .addProgramFiles(ToolHelper.getClassFilesForTestPackage(mainClass.getPackage()))
+            .addKeepRules(
+                "-keep class " + mainClass.getCanonicalName() + "{",
+                "  public <init>();",
+                "  public static void main(java.lang.String[]);",
+                "}",
+                "-dontobfuscate")
+            .addKeepRules(additionalKeepRules)
+            .enableGraphInspector()
+            .setMinApi(parameters.getApiLevel())
+            .addOptionsModification(
+                o -> {
+                  o.enableClassInlining = false;
 
-    CodeInspector inspector = new CodeInspector(app);
-    GraphInspector graphInspector = new GraphInspector(graphConsumer, inspector);
-    inspection.accept(inspector);
-    compatInspection.accept(graphInspector);
+                  // Prevent InterfaceWithDefaultMethods from being merged into
+                  // ClassImplementingInterface.
+                  o.enableVerticalClassMerging = false;
+                })
+            .compile();
+    inspection.accept(compileResult.inspector());
+    compatInspection.accept(compileResult.graphInspector());
   }
 
   private void noCompatibilityRules(GraphInspector inspector) {
@@ -557,6 +527,7 @@
 
   @Test
   public void keepDefaultMethodsTest() throws Exception {
+    assumeTrue(forceProguardCompatibility);
     runKeepDefaultMethodsTest(ImmutableList.of(
         "-keep interface " + InterfaceWithDefaultMethods.class.getCanonicalName() + "{",
         "  public int method();",