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();",