Only run horizontal class merger tests with class merging enabled
Fixes: 181940076
Change-Id: Iaf51a3dbda68f2cfbf3b7c1d2a00d419dca283cd
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingNonTrivialTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingNonTrivialTest.java
index 42df5c0..fbd058a 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingNonTrivialTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingNonTrivialTest.java
@@ -12,9 +12,8 @@
public class AbstractMethodMergingNonTrivialTest extends HorizontalClassMergingTestBase {
- public AbstractMethodMergingNonTrivialTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public AbstractMethodMergingNonTrivialTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,11 +21,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.enableInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.enableNoVerticalClassMergingAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingTest.java
index 3b0af4f..a30ca9e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/AbstractMethodMergingTest.java
@@ -12,9 +12,8 @@
public class AbstractMethodMergingTest extends HorizontalClassMergingTestBase {
- public AbstractMethodMergingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public AbstractMethodMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,11 +21,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.enableInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.enableNoVerticalClassMergingAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptResourceFileContentsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptResourceFileContentsTest.java
index db8d4c7..cdd0df8 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptResourceFileContentsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptResourceFileContentsTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -23,9 +23,8 @@
import org.junit.Test;
public class AdaptResourceFileContentsTest extends HorizontalClassMergingTestBase {
- public AdaptResourceFileContentsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public AdaptResourceFileContentsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -35,9 +34,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addOptionsModification(options -> options.dataResourceConsumer = dataResourceConsumer)
.enableNeverClassInliningAnnotations()
.addDataEntryResources(
@@ -45,8 +41,7 @@
"foo.txt", Origin.unknown(), A.class.getTypeName(), B.class.getTypeName()))
.addKeepRules("-adaptresourcefilecontents foo.txt")
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector -> inspector.assertMergedInto(B.class, A.class))
.compile()
.run(parameters.getRuntime(), Main.class)
@@ -57,11 +52,10 @@
assertThat(aClassSubject, isPresent());
ClassSubject bClassSubject = codeInspector.clazz(B.class);
- assertThat(bClassSubject, notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(bClassSubject, isAbsent());
// Check that the class name has been rewritten.
- String newClassBName =
- (enableHorizontalClassMerging ? aClassSubject : bClassSubject).getFinalName();
+ String newClassBName = aClassSubject.getFinalName();
assertEquals(
dataResourceConsumer.get("foo.txt"),
ImmutableList.of(aClassSubject.getFinalName(), newClassBName));
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java
index 090cb9e..1cbf805 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/AdaptVerticallyMergedResourceFileContentsTest.java
@@ -5,7 +5,6 @@
package com.android.tools.r8.classmerging.horizontal;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -21,9 +20,8 @@
import org.junit.Test;
public class AdaptVerticallyMergedResourceFileContentsTest extends HorizontalClassMergingTestBase {
- public AdaptVerticallyMergedResourceFileContentsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public AdaptVerticallyMergedResourceFileContentsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -33,9 +31,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addOptionsModification(options -> options.dataResourceConsumer = dataResourceConsumer)
.enableNeverClassInliningAnnotations()
.addDataEntryResources(
@@ -47,8 +42,7 @@
B.class.getTypeName()))
.addKeepRules("-adaptresourcefilecontents foo.txt")
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector -> inspector.assertMergedInto(B.class, A.class))
.addVerticallyMergedClassesInspector(
inspector -> inspector.assertMergedIntoSubtype(Parent.class))
@@ -63,11 +57,10 @@
assertThat(aClassSubject, isPresent());
ClassSubject bClassSubject = codeInspector.clazz(B.class);
- assertThat(bClassSubject, notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(bClassSubject, not(isPresent()));
// Check that the class name has been rewritten.
- String newClassName =
- (enableHorizontalClassMerging ? aClassSubject : bClassSubject).getFinalName();
+ String newClassName = aClassSubject.getFinalName();
assertEquals(
dataResourceConsumer.get("foo.txt"),
ImmutableList.of(aClassSubject.getFinalName(), aClassSubject.getFinalName(), newClassName));
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassWithInstanceFieldsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassWithInstanceFieldsTest.java
index 31a49cc..41071d8 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassWithInstanceFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassWithInstanceFieldsTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -14,9 +14,8 @@
import org.junit.Test;
public class ClassWithInstanceFieldsTest extends HorizontalClassMergingTestBase {
- public ClassWithInstanceFieldsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassWithInstanceFieldsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,21 +23,17 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A. field: 5, v: a, j: 1", "B. field: b, v: 2, j: 3")
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectCheckCastTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectCheckCastTest.java
index bc5380e..bbf9149 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectCheckCastTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectCheckCastTest.java
@@ -13,9 +13,8 @@
import org.junit.Test;
public class ClassesDistinguishedByDirectCheckCastTest extends HorizontalClassMergingTestBase {
- public ClassesDistinguishedByDirectCheckCastTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesDistinguishedByDirectCheckCastTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -23,9 +22,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectInstanceOfTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectInstanceOfTest.java
index 6551ad2..d380c43 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectInstanceOfTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByDirectInstanceOfTest.java
@@ -13,9 +13,8 @@
import org.junit.Test;
public class ClassesDistinguishedByDirectInstanceOfTest extends HorizontalClassMergingTestBase {
- public ClassesDistinguishedByDirectInstanceOfTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesDistinguishedByDirectInstanceOfTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -23,9 +22,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java
index 6017cbe..9847ac8 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistinguishedByIndirectCheckCastToInterfaceTest.java
@@ -15,9 +15,8 @@
public class ClassesDistinguishedByIndirectCheckCastToInterfaceTest
extends HorizontalClassMergingTestBase {
- public ClassesDistinguishedByIndirectCheckCastToInterfaceTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesDistinguishedByIndirectCheckCastToInterfaceTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,9 +24,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNoVerticalClassMergingAnnotations()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java
index cf05da6..8bf955c 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast.java
@@ -15,9 +15,8 @@
public class ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast
extends HorizontalClassMergingTestBase {
- public ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesDistuingishedByIndirectInstanceOfInterfaceCheckCast(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,9 +24,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentFieldsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentFieldsTest.java
index d322729..7e90337 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentFieldsTest.java
@@ -6,8 +6,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -16,9 +16,8 @@
import org.junit.Test;
public class ClassesWithDifferentFieldsTest extends HorizontalClassMergingTestBase {
- public ClassesWithDifferentFieldsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithDifferentFieldsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,22 +25,18 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.compile()
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A. v: a", "B. i: 2")
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentInterfacesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentInterfacesTest.java
index 5abdc09..497e4df 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentInterfacesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentInterfacesTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -15,9 +15,8 @@
import org.junit.Test;
public class ClassesWithDifferentInterfacesTest extends HorizontalClassMergingTestBase {
- public ClassesWithDifferentInterfacesTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithDifferentInterfacesTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,15 +24,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(Z.class, Y.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(Z.class, Y.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("bar", "foo y", "bar")
.inspect(
@@ -41,8 +37,7 @@
assertThat(codeInspector.clazz(I.class), isPresent());
assertThat(codeInspector.clazz(X.class), isPresent());
assertThat(codeInspector.clazz(Y.class), isPresent());
- assertThat(
- codeInspector.clazz(Z.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(Z.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
index 68a81b1..269b793 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithDifferentVisibilityFieldsTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static com.android.tools.r8.utils.codeinspector.Matchers.readsInstanceField;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -21,9 +21,8 @@
import org.junit.Test;
public class ClassesWithDifferentVisibilityFieldsTest extends HorizontalClassMergingTestBase {
- public ClassesWithDifferentVisibilityFieldsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithDifferentVisibilityFieldsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -31,14 +30,11 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(
"a. v1: 10, v2: 20", "b. v1: 60, v2: 100", "c. v1: 210, v2: 330")
@@ -46,31 +42,28 @@
codeInspector -> {
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
assertThat(codeInspector.clazz(C.class), isPresent());
- if (enableHorizontalClassMerging) {
- FieldSubject v1Subject = aClassSubject.uniqueFieldWithName("v1");
- FieldSubject v2Subject = aClassSubject.uniqueFieldWithName("v2");
+ FieldSubject v1Subject = aClassSubject.uniqueFieldWithName("v1");
+ FieldSubject v2Subject = aClassSubject.uniqueFieldWithName("v2");
- MethodSubject methodSubject = aClassSubject.uniqueMethodWithName("getAV1");
- assertThat(methodSubject, isPresent());
- assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
+ MethodSubject methodSubject = aClassSubject.uniqueMethodWithName("getAV1");
+ assertThat(methodSubject, isPresent());
+ assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
- methodSubject = aClassSubject.uniqueMethodWithName("getAV2");
- assertThat(methodSubject, isPresent());
- assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
+ methodSubject = aClassSubject.uniqueMethodWithName("getAV2");
+ assertThat(methodSubject, isPresent());
+ assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
- // The fields v1 and v2 are swapped, because their access modifiers are swapped.
- methodSubject = aClassSubject.uniqueMethodWithName("getBV1");
- assertThat(methodSubject, isPresent());
- assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
+ // The fields v1 and v2 are swapped, because their access modifiers are swapped.
+ methodSubject = aClassSubject.uniqueMethodWithName("getBV1");
+ assertThat(methodSubject, isPresent());
+ assertThat(methodSubject, readsInstanceField(v2Subject.getDexField()));
- methodSubject = aClassSubject.uniqueMethodWithName("getBV2");
- assertThat(methodSubject, isPresent());
- assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
- }
+ methodSubject = aClassSubject.uniqueMethodWithName("getBV2");
+ assertThat(methodSubject, isPresent());
+ assertThat(methodSubject, readsInstanceField(v1Subject.getDexField()));
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithFeatureSplitTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithFeatureSplitTest.java
index 9ac569b..3f0fac0 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithFeatureSplitTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithFeatureSplitTest.java
@@ -5,30 +5,26 @@
package com.android.tools.r8.classmerging.horizontal;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.dexsplitter.SplitterTestBase.RunInterface;
-import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import java.util.List;
import org.junit.Test;
import org.junit.runners.Parameterized;
public class ClassesWithFeatureSplitTest extends HorizontalClassMergingTestBase {
- public ClassesWithFeatureSplitTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithFeatureSplitTest(TestParameters parameters) {
+ super(parameters);
}
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters().withDexRuntimes().withAllApiLevels().build(), BooleanUtils.values());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
}
@Test
@@ -41,9 +37,6 @@
.addFeatureSplit(Feature2Class.class, Feature2Main.class)
.addKeepFeatureMainRule(Feature1Main.class)
.addKeepFeatureMainRule(Feature2Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
@@ -68,8 +61,7 @@
private void inspectFeature1(CodeInspector inspector) {
assertThat(inspector.clazz(Feature1Main.class), isPresent());
assertThat(inspector.clazz(Feature1Class1.class), isPresent());
- assertThat(
- inspector.clazz(Feature1Class2.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(inspector.clazz(Feature1Class2.class), not(isPresent()));
assertThat(inspector.clazz(Feature2Main.class), not(isPresent()));
assertThat(inspector.clazz(Feature2Class.class), not(isPresent()));
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithIdenticalInterfacesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithIdenticalInterfacesTest.java
index 6714388..9a5f503 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithIdenticalInterfacesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithIdenticalInterfacesTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -14,9 +14,8 @@
import org.junit.Test;
public class ClassesWithIdenticalInterfacesTest extends HorizontalClassMergingTestBase {
- public ClassesWithIdenticalInterfacesTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithIdenticalInterfacesTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,14 +23,10 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector ->
inspector.assertMergedInto(Y.class, X.class).assertMergedInto(Z.class, X.class))
.run(parameters.getRuntime(), Main.class)
@@ -40,10 +35,8 @@
codeInspector -> {
assertThat(codeInspector.clazz(I.class), isPresent());
assertThat(codeInspector.clazz(X.class), isPresent());
- assertThat(
- codeInspector.clazz(Y.class), notIf(isPresent(), enableHorizontalClassMerging));
- assertThat(
- codeInspector.clazz(Z.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(Y.class), isAbsent());
+ assertThat(codeInspector.clazz(Z.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java
index c551a26..dcdd8f8 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithNativeMethodsTest.java
@@ -16,9 +16,8 @@
import org.junit.Test;
public class ClassesWithNativeMethodsTest extends HorizontalClassMergingTestBase {
- public ClassesWithNativeMethodsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithNativeMethodsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,9 +25,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithOverlappingVisibilitiesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithOverlappingVisibilitiesTest.java
index 608f6fe..db0ce63 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithOverlappingVisibilitiesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithOverlappingVisibilitiesTest.java
@@ -4,10 +4,10 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPackagePrivate;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPublic;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -18,9 +18,8 @@
import org.junit.Test;
public class ClassesWithOverlappingVisibilitiesTest extends HorizontalClassMergingTestBase {
- public ClassesWithOverlappingVisibilitiesTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithOverlappingVisibilitiesTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -28,9 +27,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -45,23 +41,18 @@
ClassSubject bClassSubject = codeInspector.clazz(B.class);
assertThat(bClassSubject, isPresent());
- if (enableHorizontalClassMerging) {
- methodSubject = bClassSubject.method("void", "foo$bridge");
- assertThat(methodSubject, isPackagePrivate());
- }
+ methodSubject = bClassSubject.method("void", "foo$bridge");
+ assertThat(methodSubject, isPackagePrivate());
- assertThat(
- codeInspector.clazz(C.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(C.class), isAbsent());
ClassSubject dClassSubject = codeInspector.clazz(D.class);
assertThat(dClassSubject, isPresent());
- if (enableHorizontalClassMerging) {
- methodSubject = dClassSubject.method("void", "foo$bridge");
- assertThat(methodSubject, isPublic());
- }
+ methodSubject = dClassSubject.method("void", "foo$bridge");
+ assertThat(methodSubject, isPublic());
ClassSubject eClassSubject = codeInspector.clazz(E.class);
- assertThat(eClassSubject, notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(eClassSubject, isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithStaticFields.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithStaticFields.java
index 2810ce8..d66a630 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithStaticFields.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ClassesWithStaticFields.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -13,8 +13,8 @@
import org.junit.Test;
public class ClassesWithStaticFields extends HorizontalClassMergingTestBase {
- public ClassesWithStaticFields(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ClassesWithStaticFields(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,20 +22,16 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("a: 0", "b: 0", "a: 1", "b: 1")
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/CompanionClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/CompanionClassMergingTest.java
index 9aca9fe..364f7ed 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/CompanionClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/CompanionClassMergingTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -16,9 +16,8 @@
import org.junit.Test;
public class CompanionClassMergingTest extends HorizontalClassMergingTestBase {
- public CompanionClassMergingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public CompanionClassMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,14 +25,10 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addOptionsModification(options -> options.enableClassInlining = false)
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector -> inspector.assertMergedInto(B.Companion.class, A.Companion.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("foo a 0", "foo b 1")
@@ -43,9 +38,7 @@
assertThat(codeInspector.clazz(B.class), isPresent());
assertThat(codeInspector.clazz(A.Companion.class), isPresent());
- assertThat(
- codeInspector.clazz(B.Companion.class),
- notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.Companion.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/CompatKeepConstructorLiveTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/CompatKeepConstructorLiveTest.java
index c03361f..ccec2d8 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/CompatKeepConstructorLiveTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/CompatKeepConstructorLiveTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -14,9 +14,8 @@
import org.junit.Test;
public class CompatKeepConstructorLiveTest extends HorizontalClassMergingTestBase {
- public CompatKeepConstructorLiveTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public CompatKeepConstructorLiveTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,9 +23,6 @@
testForR8Compat(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
@@ -39,8 +35,7 @@
assertThat(aClassSubject.init(), isPresent());
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java
index 369ebfd..07cea40 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorCantInlineTest.java
@@ -5,20 +5,17 @@
package com.android.tools.r8.classmerging.horizontal;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsNot.not;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NoHorizontalClassMerging;
import com.android.tools.r8.TestParameters;
import org.junit.Test;
public class ConstructorCantInlineTest extends HorizontalClassMergingTestBase {
- public ConstructorCantInlineTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ConstructorCantInlineTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,9 +23,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -39,8 +33,7 @@
assertThat(codeInspector.clazz(A.class), not(isPresent()));
assertThat(codeInspector.clazz(B.class), isPresent());
assertThat(codeInspector.clazz(C.class), isPresent());
- assertThat(
- codeInspector.clazz(D.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(D.class), not(isPresent()));
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingAfterUnusedArgumentRemovalTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingAfterUnusedArgumentRemovalTest.java
index d38efb3..fd1a5ac 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingAfterUnusedArgumentRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingAfterUnusedArgumentRemovalTest.java
@@ -11,9 +11,8 @@
public class ConstructorMergingAfterUnusedArgumentRemovalTest
extends HorizontalClassMergingTestBase {
- public ConstructorMergingAfterUnusedArgumentRemovalTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ConstructorMergingAfterUnusedArgumentRemovalTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -21,13 +20,9 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector ->
inspector
.assertMergedInto(B.class, A.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
index 8936dc1..055ab8d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingOverlapTest.java
@@ -21,9 +21,8 @@
public class ConstructorMergingOverlapTest extends HorizontalClassMergingTestBase {
- public ConstructorMergingOverlapTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ConstructorMergingOverlapTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -31,9 +30,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -41,7 +37,6 @@
.assertSuccessWithOutputLines("42", "13", "7", "print a", "print b")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
FieldSubject classIdFieldSubject =
@@ -66,12 +61,6 @@
assertThat(printSubject, readsInstanceField(classIdFieldSubject.getDexField()));
assertThat(codeInspector.clazz(B.class), not(isPresent()));
-
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
index 4d62a05..e0c6c9e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingPreoptimizedTest.java
@@ -22,9 +22,8 @@
public class ConstructorMergingPreoptimizedTest extends HorizontalClassMergingTestBase {
- public ConstructorMergingPreoptimizedTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ConstructorMergingPreoptimizedTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -32,11 +31,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
@@ -46,38 +42,29 @@
"changed", "13", "42", "foo", "7", "foo", "print a", "print b")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
- ClassSubject changedClassSubject = codeInspector.clazz(Changed.class);
- assertThat(changedClassSubject, isPresent());
+ ClassSubject changedClassSubject = codeInspector.clazz(Changed.class);
+ assertThat(changedClassSubject, isPresent());
- ClassSubject aClassSubject = codeInspector.clazz(A.class);
- assertThat(aClassSubject, isPresent());
- FieldSubject classIdFieldSubject =
- aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
- assertThat(classIdFieldSubject, isPresent());
+ ClassSubject aClassSubject = codeInspector.clazz(A.class);
+ assertThat(aClassSubject, isPresent());
+ FieldSubject classIdFieldSubject =
+ aClassSubject.uniqueFieldWithName(ClassMerger.CLASS_ID_FIELD_NAME);
+ assertThat(classIdFieldSubject, isPresent());
- MethodSubject firstInitSubject = aClassSubject.init("int");
- assertThat(firstInitSubject, isPresent());
- assertThat(
- firstInitSubject, writesInstanceField(classIdFieldSubject.getDexField()));
+ MethodSubject firstInitSubject = aClassSubject.init("int");
+ assertThat(firstInitSubject, isPresent());
+ assertThat(firstInitSubject, writesInstanceField(classIdFieldSubject.getDexField()));
- MethodSubject otherInitSubject =
- aClassSubject.init(changedClassSubject.getFinalName(), "int");
- assertThat(otherInitSubject, isPresent());
- assertThat(
- otherInitSubject, writesInstanceField(classIdFieldSubject.getDexField()));
+ MethodSubject otherInitSubject =
+ aClassSubject.init(changedClassSubject.getFinalName(), "int");
+ assertThat(otherInitSubject, isPresent());
+ assertThat(otherInitSubject, writesInstanceField(classIdFieldSubject.getDexField()));
- MethodSubject printSubject = aClassSubject.method("void", "print$bridge");
- assertThat(printSubject, isPresent());
- assertThat(printSubject, readsInstanceField(classIdFieldSubject.getDexField()));
+ MethodSubject printSubject = aClassSubject.method("void", "print$bridge");
+ assertThat(printSubject, isPresent());
+ assertThat(printSubject, readsInstanceField(classIdFieldSubject.getDexField()));
- assertThat(codeInspector.clazz(B.class), not(isPresent()));
-
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
+ assertThat(codeInspector.clazz(B.class), not(isPresent()));
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTest.java
index 21c3486..b76442b 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTest.java
@@ -13,8 +13,8 @@
import org.junit.Test;
public class ConstructorMergingTest extends HorizontalClassMergingTestBase {
- public ConstructorMergingTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ConstructorMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,23 +22,14 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("foo", "bar")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
index 50da81e..0dd1f3e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingTrivialOverlapTest.java
@@ -21,9 +21,8 @@
public class ConstructorMergingTrivialOverlapTest extends HorizontalClassMergingTestBase {
- public ConstructorMergingTrivialOverlapTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ConstructorMergingTrivialOverlapTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -31,9 +30,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -41,7 +37,6 @@
.assertSuccessWithOutputLines("7", "42", "13", "print a", "print b")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
FieldSubject classIdFieldSubject =
@@ -66,12 +61,6 @@
assertThat(printSubject, readsInstanceField(classIdFieldSubject.getDexField()));
assertThat(codeInspector.clazz(B.class), not(isPresent()));
-
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingWithArgumentsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingWithArgumentsTest.java
index 7891de2..30a84ca 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingWithArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ConstructorMergingWithArgumentsTest.java
@@ -15,9 +15,8 @@
import org.junit.Test;
public class ConstructorMergingWithArgumentsTest extends HorizontalClassMergingTestBase {
- public ConstructorMergingWithArgumentsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ConstructorMergingWithArgumentsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,16 +24,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("foo hello", "bar world")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
@@ -42,11 +37,6 @@
MethodSubject initSubject = aClassSubject.init(String.class.getName(), "int");
assertThat(initSubject, isPresent());
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java
index 749ae58..e063a4b 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/DistinguishExceptionClassesTest.java
@@ -11,9 +11,8 @@
import org.junit.Test;
public class DistinguishExceptionClassesTest extends HorizontalClassMergingTestBase {
- public DistinguishExceptionClassesTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public DistinguishExceptionClassesTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -21,9 +20,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("test success")
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/EmptyClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/EmptyClassTest.java
index 5d63188..d33b180 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/EmptyClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/EmptyClassTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -15,8 +15,8 @@
import org.junit.Test;
public class EmptyClassTest extends HorizontalClassMergingTestBase {
- public EmptyClassTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public EmptyClassTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,20 +24,16 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("a", "b: foo")
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
index 58434a9..e688559 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldTypeMergedTest.java
@@ -4,10 +4,10 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isFieldOfArrayType;
import static com.android.tools.r8.utils.codeinspector.Matchers.isFieldOfType;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertTrue;
@@ -19,8 +19,8 @@
import org.junit.Test;
public class FieldTypeMergedTest extends HorizontalClassMergingTestBase {
- public FieldTypeMergedTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public FieldTypeMergedTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -28,9 +28,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -40,28 +37,21 @@
codeInspector -> {
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(codeInspector.clazz(C.class), isPresent());
FieldSubject fieldSubject = cClassSubject.uniqueFieldWithName("fieldB");
assertThat(fieldSubject, isPresent());
- if (enableHorizontalClassMerging) {
- assertThat(
- fieldSubject, isFieldOfType(aClassSubject.getDexProgramClass().getType()));
- }
+ assertThat(fieldSubject, isFieldOfType(aClassSubject.getDexProgramClass().getType()));
fieldSubject = cClassSubject.uniqueFieldWithName("fieldArrayB");
assertThat(fieldSubject, isPresent());
assertTrue(fieldSubject.getDexField().type.isArrayType());
- if (enableHorizontalClassMerging) {
- assertThat(
- fieldSubject,
- isFieldOfArrayType(
- codeInspector, aClassSubject.getDexProgramClass().getType()));
- }
+ assertThat(
+ fieldSubject,
+ isFieldOfArrayType(codeInspector, aClassSubject.getDexProgramClass().getType()));
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldsWithDifferentAccessFlagsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldsWithDifferentAccessFlagsTest.java
index 58acdbf..7468ce5 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldsWithDifferentAccessFlagsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/FieldsWithDifferentAccessFlagsTest.java
@@ -14,9 +14,8 @@
public class FieldsWithDifferentAccessFlagsTest extends HorizontalClassMergingTestBase {
- public FieldsWithDifferentAccessFlagsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public FieldsWithDifferentAccessFlagsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,11 +23,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/GenericStaticFieldTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/GenericStaticFieldTest.java
index af72afe..e1248e1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/GenericStaticFieldTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/GenericStaticFieldTest.java
@@ -9,8 +9,8 @@
import org.junit.Test;
public class GenericStaticFieldTest extends HorizontalClassMergingTestBase {
- public GenericStaticFieldTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public GenericStaticFieldTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -19,9 +19,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.addKeepRules("-keepattributes Signatures")
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
// .addHorizontallyMergedClassesInspectorIf(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingTestBase.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingTestBase.java
index 5b2dbe7..fa19056 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingTestBase.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/HorizontalClassMergingTestBase.java
@@ -6,29 +6,25 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.synthesis.SyntheticItemsTestUtils;
-import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import java.util.List;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
public abstract class HorizontalClassMergingTestBase extends TestBase {
- protected final TestParameters parameters;
- protected final boolean enableHorizontalClassMerging;
- protected HorizontalClassMergingTestBase(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
+ protected final TestParameters parameters;
+
+ protected HorizontalClassMergingTestBase(TestParameters parameters) {
this.parameters = parameters;
- this.enableHorizontalClassMerging = enableHorizontalClassMerging;
}
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
protected ClassSubject getSynthesizedArgumentClassSubject(CodeInspector codeInspector) {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/IdenticalFieldMembersTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/IdenticalFieldMembersTest.java
index 9dae7a2..08a3bd7 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/IdenticalFieldMembersTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/IdenticalFieldMembersTest.java
@@ -4,17 +4,16 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.*;
import org.junit.Test;
public class IdenticalFieldMembersTest extends HorizontalClassMergingTestBase {
- public IdenticalFieldMembersTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public IdenticalFieldMembersTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,9 +21,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -33,8 +29,7 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritInterfaceWithDefaultTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritInterfaceWithDefaultTest.java
index b069bb1..ef0cedf 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritInterfaceWithDefaultTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritInterfaceWithDefaultTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -18,9 +18,8 @@
public class InheritInterfaceWithDefaultTest extends HorizontalClassMergingTestBase {
- public InheritInterfaceWithDefaultTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public InheritInterfaceWithDefaultTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -29,22 +28,18 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.allowStdoutMessages()
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines(
"print interface", "print interface", "print interface", "print interface")
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritOverrideInterfaceTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritOverrideInterfaceTest.java
index 8c7644d..8bea286 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritOverrideInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritOverrideInterfaceTest.java
@@ -13,9 +13,8 @@
import org.junit.Test;
public class InheritOverrideInterfaceTest extends HorizontalClassMergingTestBase {
- public InheritOverrideInterfaceTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public InheritOverrideInterfaceTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -23,14 +22,11 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A", "B", "A")
.inspect(codeInspector -> {});
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritsFromLibraryClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritsFromLibraryClassTest.java
index 575c2cd..33a1909 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritsFromLibraryClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/InheritsFromLibraryClassTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -19,9 +19,8 @@
import org.junit.Test;
public class InheritsFromLibraryClassTest extends HorizontalClassMergingTestBase {
- public InheritsFromLibraryClassTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public InheritsFromLibraryClassTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -29,9 +28,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -41,8 +37,7 @@
codeInspector -> {
assertThat(codeInspector.clazz(Parent.class), isPresent());
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
assertThat(codeInspector.clazz(C.class), isPresent());
});
}
@@ -74,7 +69,7 @@
}
@NeverClassInline
- public static class C extends ArrayList {
+ public static class C extends ArrayList<Object> {
public C() {}
public void fooB(B b) {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/InnerOuterClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/InnerOuterClassesTest.java
index 98e74e4..a6a93ad 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/InnerOuterClassesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/InnerOuterClassesTest.java
@@ -12,8 +12,8 @@
import org.junit.Test;
public class InnerOuterClassesTest extends HorizontalClassMergingTestBase {
- public InnerOuterClassesTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public InnerOuterClassesTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -21,9 +21,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.addKeepAttributes("InnerClasses", "EnclosingMethod")
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/InstantiatedAndUninstantiatedClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/InstantiatedAndUninstantiatedClassMergingTest.java
index 59e77dd..d6b6643 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/InstantiatedAndUninstantiatedClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/InstantiatedAndUninstantiatedClassMergingTest.java
@@ -16,9 +16,8 @@
public class InstantiatedAndUninstantiatedClassMergingTest extends HorizontalClassMergingTestBase {
- public InstantiatedAndUninstantiatedClassMergingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public InstantiatedAndUninstantiatedClassMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -35,9 +34,6 @@
testBuilder
.addInnerClasses(getClass())
.addKeepMainRule(TestClass.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.addHorizontallyMergedClassesInspector(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
index f7aacb5..6f96433 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/JavaLambdaMergingTest.java
@@ -18,8 +18,8 @@
public class JavaLambdaMergingTest extends HorizontalClassMergingTestBase {
- public JavaLambdaMergingTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public JavaLambdaMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -27,11 +27,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging && parameters.isDexRuntime(),
+ parameters.isDexRuntime(),
inspector -> {
Set<DexType> lambdaSources =
inspector.getSources().stream()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/LargeConstructorsMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/LargeConstructorsMergingTest.java
index a553abe..00b1f38 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/LargeConstructorsMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/LargeConstructorsMergingTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -15,9 +15,8 @@
import org.junit.Test;
public class LargeConstructorsMergingTest extends HorizontalClassMergingTestBase {
- public LargeConstructorsMergingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public LargeConstructorsMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,14 +24,10 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addOptionsModification(options -> options.testing.verificationSizeLimitInBytesOverride = 4)
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector ->
inspector.assertMergedInto(B.class, A.class).assertMergedInto(C.class, A.class))
.run(parameters.getRuntime(), Main.class)
@@ -41,15 +36,11 @@
codeInspector -> {
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
- assertThat(
- codeInspector.clazz(C.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
+ assertThat(codeInspector.clazz(C.class), isAbsent());
- if (enableHorizontalClassMerging) {
- // There should be three constructors on class A after merging.
- assertEquals(3, aClassSubject.allMethods().size());
- }
+ // There should be three constructors on class A after merging.
+ assertEquals(3, aClassSubject.allMethods().size());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergeNonFinalAndFinalClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergeNonFinalAndFinalClassTest.java
index c8a36b6..1285ea1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergeNonFinalAndFinalClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergeNonFinalAndFinalClassTest.java
@@ -5,7 +5,7 @@
package com.android.tools.r8.classmerging.horizontal;
import static com.android.tools.r8.utils.codeinspector.Matchers.isFinal;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -14,9 +14,8 @@
import org.junit.Test;
public class MergeNonFinalAndFinalClassTest extends HorizontalClassMergingTestBase {
- public MergeNonFinalAndFinalClassTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MergeNonFinalAndFinalClassTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,19 +23,13 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
- .inspect(
- inspector ->
- assertThat(
- inspector.clazz(A.class), notIf(isFinal(), enableHorizontalClassMerging)))
+ .inspect(inspector -> assertThat(inspector.clazz(A.class), not(isFinal())))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("a", "b", "b", "c");
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergePackagePrivateWithPublicClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergePackagePrivateWithPublicClassTest.java
index 04d69b1d..409ea48 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergePackagePrivateWithPublicClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergePackagePrivateWithPublicClassTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.TestParameters;
@@ -14,9 +14,8 @@
public class MergePackagePrivateWithPublicClassTest extends HorizontalClassMergingTestBase {
- public MergePackagePrivateWithPublicClassTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MergePackagePrivateWithPublicClassTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,9 +25,6 @@
.addProgramClasses(
PackagePrivateClassRunner.class, PackagePrivateClassRunner.getPrivateClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -39,8 +35,7 @@
codeInspector -> {
assertThat(codeInspector.clazz(PackagePrivateClassRunner.class), isPresent());
assertThat(
- codeInspector.clazz(PackagePrivateClassRunner.getPrivateClass()),
- notIf(isPresent(), enableHorizontalClassMerging));
+ codeInspector.clazz(PackagePrivateClassRunner.getPrivateClass()), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
index f913560..5484fd8 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorForwardingTest.java
@@ -21,9 +21,8 @@
public class MergedConstructorForwardingTest extends HorizontalClassMergingTestBase {
- public MergedConstructorForwardingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MergedConstructorForwardingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -31,9 +30,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -41,7 +37,6 @@
.assertSuccessWithOutputLines("42", "13", "21", "39", "print a", "print b")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
ClassSubject aClassSubject = codeInspector.clazz(A.class);
assertThat(aClassSubject, isPresent());
FieldSubject classIdFieldSubject =
@@ -63,12 +58,6 @@
assertThat(printSubject, readsInstanceField(classIdFieldSubject.getDexField()));
assertThat(codeInspector.clazz(B.class), not(isPresent()));
-
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java
index a11a7d6..e785238 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedConstructorStackTraceTest.java
@@ -22,9 +22,8 @@
public StackTrace expectedStackTrace;
- public MergedConstructorStackTraceTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MergedConstructorStackTraceTest(TestParameters parameters) {
+ super(parameters);
}
@Before
@@ -45,9 +44,6 @@
.addKeepMainRule(Main.class)
.addKeepAttributeLineNumberTable()
.addKeepAttributeSourceFile()
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNoVerticalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -56,7 +52,6 @@
.inspectStackTrace(
(stackTrace, codeInspector) -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- if (enableHorizontalClassMerging) {
StackTrace expectedStackTraceWithMergedConstructor =
StackTrace.builder()
.add(expectedStackTrace)
@@ -73,10 +68,6 @@
.build();
assertThat(stackTrace, isSame(expectedStackTraceWithMergedConstructor));
assertThat(codeInspector.clazz(B.class), not(isPresent()));
- } else {
- assertThat(stackTrace, isSame(expectedStackTrace));
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStackTraceTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStackTraceTest.java
index 8c9d11d..0375885 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStackTraceTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStackTraceTest.java
@@ -5,8 +5,8 @@
package com.android.tools.r8.classmerging.horizontal;
import static com.android.tools.r8.naming.retrace.StackTrace.isSame;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -19,9 +19,8 @@
import org.junit.Test;
public class MergedVirtualMethodStackTraceTest extends HorizontalClassMergingTestBase {
- public MergedVirtualMethodStackTraceTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MergedVirtualMethodStackTraceTest(TestParameters parameters) {
+ super(parameters);
}
public StackTrace expectedStackTrace;
@@ -45,38 +44,30 @@
.addKeepAttributeLineNumberTable()
.addKeepAttributeSourceFile()
.addDontWarn(C.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector -> inspector.assertMergedInto(Program.B.class, Program.A.class))
.run(parameters.getRuntime(), Program.Main.class)
.inspectStackTrace(
(stackTrace, codeInspector) -> {
assertThat(codeInspector.clazz(Program.A.class), isPresent());
- assertThat(
- codeInspector.clazz(Program.B.class),
- notIf(isPresent(), enableHorizontalClassMerging));
- if (enableHorizontalClassMerging) {
- StackTrace expectedStackTraceWithMergedMethod =
- StackTrace.builder()
- .add(expectedStackTrace)
- .add(
- 1,
- StackTraceLine.builder()
- .setClassName(Program.A.class.getTypeName())
- .setMethodName("foo$bridge")
- .setFileName("Program.java")
- .setFileName(getClass().getSimpleName() + ".java")
- .setLineNumber(stackTrace.get(1).lineNumber)
- .build())
- .build();
- assertThat(stackTrace, isSame(expectedStackTraceWithMergedMethod));
- }
+ assertThat(codeInspector.clazz(Program.B.class), isAbsent());
+ StackTrace expectedStackTraceWithMergedMethod =
+ StackTrace.builder()
+ .add(expectedStackTrace)
+ .add(
+ 1,
+ StackTraceLine.builder()
+ .setClassName(Program.A.class.getTypeName())
+ .setMethodName("foo$bridge")
+ .setFileName("Program.java")
+ .setFileName(getClass().getSimpleName() + ".java")
+ .setLineNumber(stackTrace.get(1).lineNumber)
+ .build())
+ .build();
+ assertThat(stackTrace, isSame(expectedStackTraceWithMergedMethod));
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStaticizerTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStaticizerTest.java
index e7eda20..3ffb5a2 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergedVirtualMethodStaticizerTest.java
@@ -10,9 +10,8 @@
import org.junit.Test;
public class MergedVirtualMethodStaticizerTest extends HorizontalClassMergingTestBase {
- public MergedVirtualMethodStaticizerTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MergedVirtualMethodStaticizerTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -20,14 +19,10 @@
testForR8(parameters.getBackend())
.addInnerClasses(Program.class)
.addKeepClassAndMembersRules(Program.Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector -> inspector.assertMergedInto(Program.B.class, Program.A.class))
.run(parameters.getRuntime(), Program.Main.class)
.assertSuccessWithOutputLines("A::foo", "Staticized::foo", "B::foo");
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java
index 13cc54f..06242c1 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MergingProducesFieldCollisionTest.java
@@ -4,22 +4,20 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import org.junit.Test;
public class MergingProducesFieldCollisionTest extends HorizontalClassMergingTestBase {
- public MergingProducesFieldCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MergingProducesFieldCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -30,9 +28,6 @@
.addKeepMainRule(Main.class)
.addProgramClassFileData(transformedC)
.addProgramClasses(Parent.class, A.class, B.class, Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -46,16 +41,13 @@
assertThat(aClassSubject, isPresent());
ClassSubject bClassSubject = codeInspector.clazz(B.class);
- assertThat(bClassSubject, notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(bClassSubject, isAbsent());
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
- if (enableHorizontalClassMerging) {
- assertEquals(
- cClassSubject.allFields().get(0).type(),
- cClassSubject.allFields().get(1).type());
- }
+ assertEquals(
+ cClassSubject.allFields().get(0).type(), cClassSubject.allFields().get(1).type());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/MinimizeFieldCastsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/MinimizeFieldCastsTest.java
index 90ae326..319e1c0 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/MinimizeFieldCastsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/MinimizeFieldCastsTest.java
@@ -12,8 +12,8 @@
public class MinimizeFieldCastsTest extends HorizontalClassMergingTestBase {
- public MinimizeFieldCastsTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public MinimizeFieldCastsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -21,15 +21,11 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector ->
// Two merge groups are expected since we attempt to merge classes in a way that
// avoids merging fields with different types unless strictly required for merging.
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java
index a043e68..215ce7a 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java
@@ -4,24 +4,23 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPrivate;
import static com.android.tools.r8.utils.codeinspector.Matchers.isStatic;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.classmerging.horizontal.NestClassTest.R.horizontalclassmerging.BasicNestHostHorizontalClassMerging;
import com.android.tools.r8.classmerging.horizontal.NestClassTest.R.horizontalclassmerging.BasicNestHostHorizontalClassMerging2;
-import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesClass;
import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesJava11RootPackage;
import com.android.tools.r8.utils.ReflectiveBuildPathUtils.ExamplesPackage;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
import org.junit.Test;
import org.junit.runners.Parameterized;
@@ -42,15 +41,13 @@
}
}
- public NestClassTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public NestClassTest(TestParameters parameters) {
+ super(parameters);
}
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters().withCfRuntimesStartingFromIncluding(CfVm.JDK11).build(),
- BooleanUtils.values());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withCfRuntimesStartingFromIncluding(CfVm.JDK11).build();
}
@Test
@@ -59,9 +56,6 @@
.addKeepMainRule(examplesTypeName(BasicNestHostHorizontalClassMerging.class))
.addExamplesProgramFiles(R.class)
.applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.compile()
@@ -98,11 +92,11 @@
assertThat(
codeInspector.clazz(
examplesTypeName(BasicNestHostHorizontalClassMerging.B.class)),
- notIf(isPresent(), enableHorizontalClassMerging));
+ isAbsent());
assertThat(
codeInspector.clazz(
examplesTypeName(BasicNestHostHorizontalClassMerging2.B.class)),
- notIf(isPresent(), enableHorizontalClassMerging));
+ isAbsent());
// TODO(b/165517236): Explicitly check 1.B is merged into 1.A, and 2.B into 2.A.
});
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoAbstractClassesWithNonAbstractClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoAbstractClassesWithNonAbstractClassesTest.java
index 5566f45..4ebbd51 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoAbstractClassesWithNonAbstractClassesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoAbstractClassesWithNonAbstractClassesTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -15,9 +15,8 @@
import org.junit.Test;
public class NoAbstractClassesWithNonAbstractClassesTest extends HorizontalClassMergingTestBase {
- public NoAbstractClassesWithNonAbstractClassesTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public NoAbstractClassesWithNonAbstractClassesTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,9 +24,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -39,8 +35,7 @@
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), isPresent());
assertThat(codeInspector.clazz(C.class), isPresent());
- assertThat(
- codeInspector.clazz(D.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(D.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoClassesOrMembersWithAnnotationsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoClassesOrMembersWithAnnotationsTest.java
index 441934e..385a3fe 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoClassesOrMembersWithAnnotationsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoClassesOrMembersWithAnnotationsTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -20,9 +20,9 @@
import org.junit.Test;
public class NoClassesOrMembersWithAnnotationsTest extends HorizontalClassMergingTestBase {
- public NoClassesOrMembersWithAnnotationsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+
+ public NoClassesOrMembersWithAnnotationsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -31,11 +31,7 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector -> inspector.assertIsCompleteMergeGroup(A.class, C.class))
.enableNeverClassInliningAnnotations()
.enableInliningAnnotations()
@@ -49,8 +45,7 @@
assertThat(codeInspector.clazz(MethodAnnotation.class), isPresent());
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), isPresent());
- assertThat(
- codeInspector.clazz(C.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(C.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoHorizontalClassMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoHorizontalClassMergingTest.java
index 5c0e207..1382648 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NoHorizontalClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NoHorizontalClassMergingTest.java
@@ -13,9 +13,8 @@
import org.junit.Test;
public class NoHorizontalClassMergingTest extends HorizontalClassMergingTestBase {
- public NoHorizontalClassMergingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public NoHorizontalClassMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -23,9 +22,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNoHorizontalClassMergingAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -33,13 +29,8 @@
.assertSuccessWithOutputLines("a", "b")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), isPresent());
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
index d73ffcf..110f7f6 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonFinalOverrideOfFinalMethodTest.java
@@ -12,24 +12,21 @@
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
import org.junit.Test;
import org.junit.runners.Parameterized;
public class NonFinalOverrideOfFinalMethodTest extends HorizontalClassMergingTestBase {
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.trueValues());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
- public NonFinalOverrideOfFinalMethodTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public NonFinalOverrideOfFinalMethodTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -37,15 +34,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.compile()
.inspect(
inspector -> {
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
index 029035e..a54102f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessOnMergedClassTest.java
@@ -14,9 +14,8 @@
@RunWith(Parameterized.class)
public class NonReboundFieldAccessOnMergedClassTest extends HorizontalClassMergingTestBase {
- public NonReboundFieldAccessOnMergedClassTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public NonReboundFieldAccessOnMergedClassTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,11 +24,8 @@
.addInnerClasses(getClass())
.addInnerClasses(NonReboundFieldAccessOnMergedClassTestClasses.class)
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(D.class, C.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(D.class, C.class))
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java
index 03b99e0..4b17a09 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NonReboundFieldAccessWithMergedTypeTest.java
@@ -14,9 +14,8 @@
@RunWith(Parameterized.class)
public class NonReboundFieldAccessWithMergedTypeTest extends HorizontalClassMergingTestBase {
- public NonReboundFieldAccessWithMergedTypeTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public NonReboundFieldAccessWithMergedTypeTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,11 +24,7 @@
.addInnerClasses(getClass())
.addInnerClasses(NonReboundFieldAccessWithMergedTypeTestClasses.class)
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector -> inspector.assertMergedInto(WorldGreeting.class, HelloGreeting.class))
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/OverlappingConstructorsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/OverlappingConstructorsTest.java
index c97e384..2927247 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/OverlappingConstructorsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/OverlappingConstructorsTest.java
@@ -14,9 +14,8 @@
public class OverlappingConstructorsTest extends HorizontalClassMergingTestBase {
- public OverlappingConstructorsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public OverlappingConstructorsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,24 +23,14 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), not(isPresent()));
assertThat(codeInspector.clazz(C.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- assertThat(codeInspector.clazz(C.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMemberAccessTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMemberAccessTest.java
index 2732240..820af37 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMemberAccessTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMemberAccessTest.java
@@ -15,9 +15,8 @@
import org.junit.Test;
public class PackagePrivateMemberAccessTest extends HorizontalClassMergingTestBase {
- public PackagePrivateMemberAccessTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PackagePrivateMemberAccessTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -27,9 +26,6 @@
.addProgramClasses(A.class)
.addProgramClasses(B.class)
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.allowAccessModification(false)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
@@ -38,16 +34,9 @@
.assertSuccessWithOutputLines("foo", "B", "bar", "5", "foobar")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), not(isPresent()));
assertThat(codeInspector.clazz(C.class), isPresent());
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- assertThat(codeInspector.clazz(C.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMembersAccessedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMembersAccessedTest.java
index 4d7c0c4..bb756d0 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMembersAccessedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PackagePrivateMembersAccessedTest.java
@@ -14,9 +14,8 @@
import org.junit.Test;
public class PackagePrivateMembersAccessedTest extends HorizontalClassMergingTestBase {
- public PackagePrivateMembersAccessedTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PackagePrivateMembersAccessedTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,9 +25,6 @@
.addProgramClasses(C.class)
.addProgramClasses(D.class)
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.allowAccessModification(false)
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberReferenceTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberReferenceTest.java
index 2f01f90..41694f6 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberReferenceTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberReferenceTest.java
@@ -18,18 +18,14 @@
import org.junit.Test;
public class PinnedClassMemberReferenceTest extends HorizontalClassMergingTestBase {
- public PinnedClassMemberReferenceTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PinnedClassMemberReferenceTest(TestParameters parameters) {
+ super(parameters);
}
private R8FullTestBuilder testCommon() throws Exception {
return testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.noMinification()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
@@ -46,7 +42,6 @@
@Test
public void testWithoutKeepRules() throws Exception {
// This is just a small check ensure that without the keep rules the classes are merged.
- assumeTrue(enableHorizontalClassMerging);
assumeTrue(parameters.isCfRuntime());
runAndAssertOutput(testCommon())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberTest.java
index 1e09a5a..ca080ae 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassMemberTest.java
@@ -12,8 +12,8 @@
import org.junit.Test;
public class PinnedClassMemberTest extends HorizontalClassMergingTestBase {
- public PinnedClassMemberTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PinnedClassMemberTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,9 +22,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.addKeepRules("-keepclassmembers class " + B.class.getTypeName() + " { void foo(); }")
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassTest.java
index 0ba06e6..af092cc 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PinnedClassTest.java
@@ -12,8 +12,8 @@
import org.junit.Test;
public class PinnedClassTest extends HorizontalClassMergingTestBase {
- public PinnedClassTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PinnedClassTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,9 +22,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.addKeepClassRules(B.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexListTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexListTest.java
index e3e1b85..613cc0b 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexListTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexListTest.java
@@ -12,32 +12,28 @@
import com.android.tools.r8.OutputMode;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.A;
import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.B;
import com.android.tools.r8.classmerging.horizontal.EmptyClassTest.Main;
-import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.nio.file.Path;
-import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
public class PreventMergeMainDexListTest extends HorizontalClassMergingTestBase {
- public PreventMergeMainDexListTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PreventMergeMainDexListTest(TestParameters parameters) {
+ super(parameters);
}
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters()
- .withDexRuntimes()
- .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
- .build(),
- BooleanUtils.values());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withDexRuntimes()
+ .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+ .build();
}
@Test
@@ -46,11 +42,7 @@
.addInnerClasses(getClass())
.addKeepClassAndMembersRules(Main.class)
.addMainDexListClasses(A.class, Main.class)
- .addOptionsModification(
- options -> {
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging);
- options.minimalMainDex = true;
- })
+ .addOptionsModification(options -> options.minimalMainDex = true)
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexTracingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexTracingTest.java
index 13d8a62..a97e6f5 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexTracingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PreventMergeMainDexTracingTest.java
@@ -13,29 +13,25 @@
import com.android.tools.r8.OutputMode;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.nio.file.Path;
-import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
public class PreventMergeMainDexTracingTest extends HorizontalClassMergingTestBase {
- public PreventMergeMainDexTracingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PreventMergeMainDexTracingTest(TestParameters parameters) {
+ super(parameters);
}
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters()
- .withDexRuntimes()
- .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
- .build(),
- BooleanUtils.values());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters()
+ .withDexRuntimes()
+ .withApiLevelsEndingAtExcluding(apiLevelWithNativeMultiDexSupport())
+ .build();
}
@Test
@@ -45,11 +41,7 @@
.addKeepMainRule(Main.class)
.addKeepClassAndMembersRules(Other.class)
.addMainDexClassRules(Main.class)
- .addOptionsModification(
- options -> {
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging);
- options.minimalMainDex = true;
- })
+ .addOptionsModification(options -> options.minimalMainDex = true)
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java
index 4553469..f440689 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndInterfaceMethodCollisionTest.java
@@ -14,9 +14,8 @@
public class PrivateAndInterfaceMethodCollisionTest extends HorizontalClassMergingTestBase {
- public PrivateAndInterfaceMethodCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PrivateAndInterfaceMethodCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,9 +23,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addHorizontallyMergedClassesInspector(
HorizontallyMergedClassesInspector::assertNoClassesMerged)
.enableInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndStaticMethodCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndStaticMethodCollisionTest.java
index 3c7b799..a646bf3 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndStaticMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/PrivateAndStaticMethodCollisionTest.java
@@ -11,9 +11,8 @@
public class PrivateAndStaticMethodCollisionTest extends HorizontalClassMergingTestBase {
- public PrivateAndStaticMethodCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public PrivateAndStaticMethodCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -21,11 +20,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ReferencedInAnnotationTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ReferencedInAnnotationTest.java
index 385d782..08f1f0d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ReferencedInAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ReferencedInAnnotationTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@@ -26,9 +26,8 @@
public class ReferencedInAnnotationTest extends HorizontalClassMergingTestBase {
- public ReferencedInAnnotationTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ReferencedInAnnotationTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -37,9 +36,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(TestClass.class)
.addKeepClassAndMembersRules(Annotation.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addKeepRuntimeVisibleAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -58,7 +54,7 @@
// B should have been merged into A if horizontal class merging is enabled.
ClassSubject bClassSubject = inspector.clazz(B.class);
- assertThat(bClassSubject, notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(bClassSubject, isAbsent());
// The annotation on TestClass should now refer to A instead of B.
AnnotationSubject annotationSubject =
@@ -72,11 +68,7 @@
assertTrue(annotationElementValue.isDexValueType());
DexType annotationElementValueType = annotationElementValue.asDexValueType().getValue();
- assertEquals(
- (enableHorizontalClassMerging ? aClassSubject : bClassSubject)
- .getDexProgramClass()
- .getType(),
- annotationElementValueType);
+ assertEquals(aClassSubject.getDexProgramClass().getType(), annotationElementValueType);
}
@Annotation(B.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapFieldTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapFieldTest.java
index 168d6ee..3abb15d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapFieldTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapFieldTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -14,8 +14,8 @@
import org.junit.Test;
public class RemapFieldTest extends HorizontalClassMergingTestBase {
- public RemapFieldTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public RemapFieldTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -23,14 +23,10 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector ->
inspector.assertMergedInto(B.class, A.class).assertMergedInto(D.class, C.class))
.run(parameters.getRuntime(), Main.class)
@@ -38,11 +34,9 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
assertThat(codeInspector.clazz(C.class), isPresent());
- assertThat(
- codeInspector.clazz(D.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(D.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapMethodTest.java
index c640ffc..71e3e74 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/RemapMethodTest.java
@@ -14,8 +14,8 @@
import org.junit.Test;
public class RemapMethodTest extends HorizontalClassMergingTestBase {
- public RemapMethodTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public RemapMethodTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -23,9 +23,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -36,14 +33,8 @@
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(C.class), isPresent());
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(B.class), not(isPresent()));
assertThat(codeInspector.clazz(D.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(B.class), isPresent());
- assertThat(codeInspector.clazz(D.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderParentTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderParentTest.java
index 5eab9c9..311d835 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderParentTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderParentTest.java
@@ -18,8 +18,8 @@
import org.junit.Test;
public class ServiceLoaderParentTest extends HorizontalClassMergingTestBase {
- public ServiceLoaderParentTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ServiceLoaderParentTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -37,9 +37,6 @@
"META-INF/services/" + A.class.getTypeName(),
Origin.unknown()))
.enableNoVerticalClassMergingAnnotations()
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccess()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderTest.java
index f9ae4bd..0b4a848 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/ServiceLoaderTest.java
@@ -17,8 +17,8 @@
import org.junit.Test;
public class ServiceLoaderTest extends HorizontalClassMergingTestBase {
- public ServiceLoaderTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public ServiceLoaderTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -35,9 +35,6 @@
StringUtils.lines(serviceImplementations).getBytes(),
"META-INF/services/" + A.class.getTypeName(),
Origin.unknown()))
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
.assertSuccess()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java
index e76dd447..48844ff 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndInterfaceMethodCollisionTest.java
@@ -14,9 +14,8 @@
public class StaticAndInterfaceMethodCollisionTest extends HorizontalClassMergingTestBase {
- public StaticAndInterfaceMethodCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public StaticAndInterfaceMethodCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,9 +23,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.addHorizontallyMergedClassesInspector(
HorizontallyMergedClassesInspector::assertNoClassesMerged)
.enableInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndVirtualMethodCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndVirtualMethodCollisionTest.java
index 35a15e5..993dd65 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndVirtualMethodCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/StaticAndVirtualMethodCollisionTest.java
@@ -12,9 +12,8 @@
public class StaticAndVirtualMethodCollisionTest extends HorizontalClassMergingTestBase {
- public StaticAndVirtualMethodCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public StaticAndVirtualMethodCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,11 +21,8 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, inspector -> inspector.assertMergedInto(B.class, A.class))
+ .addHorizontallyMergedClassesInspector(
+ inspector -> inspector.assertMergedInto(B.class, A.class))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
index 762824f..4d793a4 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/StrictMethodMergingTest.java
@@ -12,23 +12,21 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
import org.junit.Test;
import org.junit.runners.Parameterized;
public class StrictMethodMergingTest extends HorizontalClassMergingTestBase {
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.trueValues());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
- public StrictMethodMergingTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public StrictMethodMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -36,14 +34,10 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector ->
inspector.assertMergedInto(B.class, A.class).assertMergedInto(D.class, C.class))
.compile()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/SuperConstructorCallsVirtualMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/SuperConstructorCallsVirtualMethodTest.java
index ecbd84b..821d644 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/SuperConstructorCallsVirtualMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/SuperConstructorCallsVirtualMethodTest.java
@@ -14,9 +14,8 @@
import org.junit.Test;
public class SuperConstructorCallsVirtualMethodTest extends HorizontalClassMergingTestBase {
- public SuperConstructorCallsVirtualMethodTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public SuperConstructorCallsVirtualMethodTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,9 +23,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -34,16 +30,9 @@
.assertSuccessWithOutputLines("5", "foo hello", "B", "bar world", "5", "B")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(Parent.class), isPresent());
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(Parent.class), isPresent());
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedClassesTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedClassesTest.java
index 6f458b7..a88c32b 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedClassesTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedClassesTest.java
@@ -15,8 +15,8 @@
import org.junit.Test;
public class SynchronizedClassesTest extends HorizontalClassMergingTestBase {
- public SynchronizedClassesTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public SynchronizedClassesTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,10 +24,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options -> {
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging);
- })
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -38,7 +34,6 @@
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), isPresent());
- if (enableHorizontalClassMerging) {
// C has been merged into A.
assertThat(codeInspector.clazz(C.class), not(isPresent()));
assertThat(codeInspector.clazz(A.class).init("long"), isPresent());
@@ -47,10 +42,6 @@
assertThat(codeInspector.clazz(D.class), not(isPresent()));
ClassSubject bClassSubject = codeInspector.clazz(B.class);
assertThat(bClassSubject.init("boolean"), isPresent());
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
index 8d802c4..4811a41 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/SynchronizedMethodMergingTest.java
@@ -12,24 +12,21 @@
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.List;
import org.junit.Test;
import org.junit.runners.Parameterized;
public class SynchronizedMethodMergingTest extends HorizontalClassMergingTestBase {
- @Parameterized.Parameters(name = "{0}, horizontalClassMerging:{1}")
- public static List<Object[]> data() {
- return buildParameters(
- getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.trueValues());
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
- public SynchronizedMethodMergingTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public SynchronizedMethodMergingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -37,14 +34,10 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging,
+ .addHorizontallyMergedClassesInspector(
inspector ->
inspector.assertMergedInto(B.class, A.class).assertMergedInto(D.class, C.class))
.compile()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/SyntheticConstructorArgumentsMerged.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/SyntheticConstructorArgumentsMerged.java
index 6567764..eb3fe19 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/SyntheticConstructorArgumentsMerged.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/SyntheticConstructorArgumentsMerged.java
@@ -14,9 +14,8 @@
import org.junit.Test;
public class SyntheticConstructorArgumentsMerged extends HorizontalClassMergingTestBase {
- public SyntheticConstructorArgumentsMerged(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public SyntheticConstructorArgumentsMerged(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,10 +23,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options -> {
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging);
- })
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -36,14 +31,8 @@
.assertSuccessWithOutputLines("5", "42")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerCollisionTest.java
index 97e41db..2b56278 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerCollisionTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -16,8 +16,8 @@
import org.junit.Test;
public class TreeFixerCollisionTest extends HorizontalClassMergingTestBase {
- public TreeFixerCollisionTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public TreeFixerCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,9 +25,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -39,13 +36,11 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
assertThat(codeInspector.clazz(Group2.class), isPresent());
assertThat(codeInspector.clazz(C.class), isPresent());
assertThat(codeInspector.clazz(D.class), isPresent());
- assertThat(
- codeInspector.clazz(E.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(E.class), isAbsent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java
index 5239543..c5dff9d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerConstructorCollisionTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -15,9 +15,8 @@
import org.junit.Test;
public class TreeFixerConstructorCollisionTest extends HorizontalClassMergingTestBase {
- public TreeFixerConstructorCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public TreeFixerConstructorCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,9 +24,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
@@ -43,8 +39,7 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
assertThat(codeInspector.clazz(C.class), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
index dbc83c8..fb7e05e 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceCollisionTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -22,9 +22,8 @@
* changed.
*/
public class TreeFixerInterfaceCollisionTest extends HorizontalClassMergingTestBase {
- public TreeFixerInterfaceCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public TreeFixerInterfaceCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -33,9 +32,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.noMinification()
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -46,15 +42,12 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
ClassSubject parentClassSubject = codeInspector.clazz(Parent.class);
assertThat(parentClassSubject, isPresent());
- if (enableHorizontalClassMerging) {
- // Parent#foo is renamed to Parent#foo1 to prevent collision.
- assertThat(parentClassSubject.uniqueMethodWithName("foo$1"), isPresent());
- }
+ // Parent#foo is renamed to Parent#foo1 to prevent collision.
+ assertThat(parentClassSubject.uniqueMethodWithName("foo$1"), isPresent());
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
index 169a59b..4dfb6df 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceFixedCollisionTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -22,9 +22,8 @@
* changed.
*/
public class TreeFixerInterfaceFixedCollisionTest extends HorizontalClassMergingTestBase {
- public TreeFixerInterfaceFixedCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public TreeFixerInterfaceFixedCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -33,9 +32,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.noMinification()
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -46,15 +42,12 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
ClassSubject parentClassSubject = codeInspector.clazz(Parent.class);
assertThat(parentClassSubject, isPresent());
- if (enableHorizontalClassMerging) {
- // Parent#foo is renamed to Parent#foo1 to prevent collision.
- assertThat(parentClassSubject.uniqueMethodWithFinalName("foo$1"), isPresent());
- }
+ // Parent#foo is renamed to Parent#foo1 to prevent collision.
+ assertThat(parentClassSubject.uniqueMethodWithFinalName("foo$1"), isPresent());
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceImplementedByParentTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceImplementedByParentTest.java
index afee32c..65b57aa 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceImplementedByParentTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerInterfaceImplementedByParentTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -22,9 +22,8 @@
* changed.
*/
public class TreeFixerInterfaceImplementedByParentTest extends HorizontalClassMergingTestBase {
- public TreeFixerInterfaceImplementedByParentTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public TreeFixerInterfaceImplementedByParentTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -33,9 +32,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.noMinification()
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -46,17 +42,14 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
ClassSubject parentClassSubject = codeInspector.clazz(Parent.class);
assertThat(parentClassSubject, isPresent());
// Parent #foo(A) is kept as is.
- if (enableHorizontalClassMerging) {
- // Parent#foo(B) is renamed to Parent#foo1 to prevent collision.
- assertThat(parentClassSubject.uniqueMethodWithFinalName("foo"), isPresent());
- assertThat(parentClassSubject.uniqueMethodWithFinalName("foo$1"), isPresent());
- }
+ // Parent#foo(B) is renamed to Parent#foo1 to prevent collision.
+ assertThat(parentClassSubject.uniqueMethodWithFinalName("foo"), isPresent());
+ assertThat(parentClassSubject.uniqueMethodWithFinalName("foo$1"), isPresent());
assertThat(codeInspector.clazz(C.class), isPresent());
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerSubClassCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerSubClassCollisionTest.java
index b68f291..5e8b88d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerSubClassCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/TreeFixerSubClassCollisionTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -17,9 +17,8 @@
import org.junit.Test;
public class TreeFixerSubClassCollisionTest extends HorizontalClassMergingTestBase {
- public TreeFixerSubClassCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public TreeFixerSubClassCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -28,9 +27,6 @@
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
.noMinification()
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -42,24 +38,18 @@
.inspect(
codeInspector -> {
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), isAbsent());
ClassSubject cClassSubject = codeInspector.clazz(C.class);
assertThat(cClassSubject, isPresent());
// C#foo(B) is renamed to C#foo$1(A).
- if (enableHorizontalClassMerging) {
- assertThat(cClassSubject.uniqueMethodWithFinalName("foo"), isPresent());
- assertThat(cClassSubject.uniqueMethodWithFinalName("foo$1"), isPresent());
- }
+ assertThat(cClassSubject.uniqueMethodWithFinalName("foo"), isPresent());
+ assertThat(cClassSubject.uniqueMethodWithFinalName("foo$1"), isPresent());
ClassSubject dClassSubject = codeInspector.clazz(D.class);
assertThat(dClassSubject, isPresent());
// D#foo$1(B) is renamed to D#foo$2(A).
- assertThat(
- dClassSubject.uniqueMethodWithFinalName(
- enableHorizontalClassMerging ? "foo$1$1" : "foo$1"),
- isPresent());
+ assertThat(dClassSubject.uniqueMethodWithFinalName("foo$1$1"), isPresent());
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticalMergingPreoptimizedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticalMergingPreoptimizedTest.java
index b1c0b4a..db15d9c 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticalMergingPreoptimizedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticalMergingPreoptimizedTest.java
@@ -5,7 +5,6 @@
package com.android.tools.r8.classmerging.horizontal;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsNot.not;
@@ -17,9 +16,8 @@
public class VerticalMergingPreoptimizedTest extends HorizontalClassMergingTestBase {
- public VerticalMergingPreoptimizedTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public VerticalMergingPreoptimizedTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -27,9 +25,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoHorizontalClassMergingAnnotations()
@@ -42,8 +37,7 @@
assertThat(codeInspector.clazz(Parent.class), not(isPresent()));
assertThat(codeInspector.clazz(Changed.class), isPresent());
assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(
- codeInspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(codeInspector.clazz(B.class), not(isPresent()));
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java
index eba6de8..0c13090 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByCheckCastTest.java
@@ -12,9 +12,8 @@
public class VerticallyMergedClassDistinguishedByCheckCastTest
extends HorizontalClassMergingTestBase {
- public VerticallyMergedClassDistinguishedByCheckCastTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public VerticallyMergedClassDistinguishedByCheckCastTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,9 +21,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java
index 47994ef..a7a9f96 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassDistinguishedByInstanceOfTest.java
@@ -12,9 +12,8 @@
public class VerticallyMergedClassDistinguishedByInstanceOfTest
extends HorizontalClassMergingTestBase {
- public VerticallyMergedClassDistinguishedByInstanceOfTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public VerticallyMergedClassDistinguishedByInstanceOfTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,9 +21,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassTest.java
index abd38f5..ab48235 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VerticallyMergedClassTest.java
@@ -15,9 +15,8 @@
import org.junit.Test;
public class VerticallyMergedClassTest extends HorizontalClassMergingTestBase {
- public VerticallyMergedClassTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public VerticallyMergedClassTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,9 +24,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableNoHorizontalClassMergingAnnotations()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfFinalAndNonFinalMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfFinalAndNonFinalMethodTest.java
index 6399f3e..0c51c89 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfFinalAndNonFinalMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfFinalAndNonFinalMethodTest.java
@@ -4,8 +4,8 @@
package com.android.tools.r8.classmerging.horizontal;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.NeverClassInline;
@@ -17,9 +17,8 @@
public class VirtualMethodMergingOfFinalAndNonFinalMethodTest
extends HorizontalClassMergingTestBase {
- public VirtualMethodMergingOfFinalAndNonFinalMethodTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public VirtualMethodMergingOfFinalAndNonFinalMethodTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -27,9 +26,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(TestClass.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -38,8 +34,7 @@
.inspect(
inspector -> {
assertThat(inspector.clazz(A.class), isPresent());
- assertThat(
- inspector.clazz(B.class), notIf(isPresent(), enableHorizontalClassMerging));
+ assertThat(inspector.clazz(B.class), isAbsent());
assertThat(inspector.clazz(C.class), isPresent());
})
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfPublicizedMethodsTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfPublicizedMethodsTest.java
index 5e23840..d3665e0 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfPublicizedMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/VirtualMethodMergingOfPublicizedMethodsTest.java
@@ -14,9 +14,8 @@
@RunWith(Parameterized.class)
public class VirtualMethodMergingOfPublicizedMethodsTest extends HorizontalClassMergingTestBase {
- public VirtualMethodMergingOfPublicizedMethodsTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public VirtualMethodMergingOfPublicizedMethodsTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -24,9 +23,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(TestClass.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.allowAccessModification()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/NotOverlappingTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/NotOverlappingTest.java
index e405aa9..3d0fe4a 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/NotOverlappingTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/NotOverlappingTest.java
@@ -13,8 +13,8 @@
import org.junit.Test;
public class NotOverlappingTest extends HorizontalClassMergingTestBase {
- public NotOverlappingTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public NotOverlappingTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -22,9 +22,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -32,14 +29,8 @@
.assertSuccessWithOutputLines("foo", "bar")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
index 11164b1..3787201 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideAbstractMethodWithDefaultTest.java
@@ -17,9 +17,8 @@
public class OverrideAbstractMethodWithDefaultTest extends HorizontalClassMergingTestBase {
- public OverrideAbstractMethodWithDefaultTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public OverrideAbstractMethodWithDefaultTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -27,15 +26,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("J", "B2")
.inspect(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java
index 15ca564..d74ae0a 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultMethodTest.java
@@ -16,9 +16,8 @@
import org.junit.Test;
public class OverrideDefaultMethodTest extends HorizontalClassMergingTestBase {
- public OverrideDefaultMethodTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public OverrideDefaultMethodTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,15 +25,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("I", "B", "J")
.inspect(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java
index 2aea3d0..95dc561 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideDefaultOnSuperMethodTest.java
@@ -17,9 +17,8 @@
import org.junit.Test;
public class OverrideDefaultOnSuperMethodTest extends HorizontalClassMergingTestBase {
- public OverrideDefaultOnSuperMethodTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public OverrideDefaultOnSuperMethodTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -27,16 +26,13 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoUnusedInterfaceRemovalAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("I", "B", "J")
.inspect(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
index 9a727f5..6f5e761 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideMergeAbsentTest.java
@@ -16,8 +16,8 @@
import org.junit.Test;
public class OverrideMergeAbsentTest extends HorizontalClassMergingTestBase {
- public OverrideMergeAbsentTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public OverrideMergeAbsentTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,15 +25,12 @@
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
.setMinApi(parameters.getApiLevel())
- .addHorizontallyMergedClassesInspectorIf(
- enableHorizontalClassMerging, HorizontallyMergedClassesInspector::assertNoClassesMerged)
+ .addHorizontallyMergedClassesInspector(
+ HorizontallyMergedClassesInspector::assertNoClassesMerged)
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("A", "B", "A", "J")
.inspect(
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideParentCollisionTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideParentCollisionTest.java
index 639cf19..c62f59b 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideParentCollisionTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/OverrideParentCollisionTest.java
@@ -16,9 +16,8 @@
public class OverrideParentCollisionTest extends HorizontalClassMergingTestBase {
- public OverrideParentCollisionTest(
- TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public OverrideParentCollisionTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -26,9 +25,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(this.getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.setMinApi(parameters.getApiLevel())
@@ -36,14 +32,8 @@
.assertSuccessWithOutputLines("foo", "bar", "foo", "parent")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(A.class), isPresent());
assertThat(codeInspector.clazz(B.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(A.class), isPresent());
- assertThat(codeInspector.clazz(B.class), isPresent());
- }
});
}
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/SuperMethodMergedTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/SuperMethodMergedTest.java
index 44973bc..fb2189d 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/SuperMethodMergedTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/dispatch/SuperMethodMergedTest.java
@@ -16,8 +16,8 @@
import org.junit.Test;
public class SuperMethodMergedTest extends HorizontalClassMergingTestBase {
- public SuperMethodMergedTest(TestParameters parameters, boolean enableHorizontalClassMerging) {
- super(parameters, enableHorizontalClassMerging);
+ public SuperMethodMergedTest(TestParameters parameters) {
+ super(parameters);
}
@Test
@@ -25,9 +25,6 @@
testForR8(parameters.getBackend())
.addInnerClasses(this.getClass())
.addKeepMainRule(Main.class)
- .addOptionsModification(
- options ->
- options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.enableNoVerticalClassMergingAnnotations()
@@ -36,18 +33,10 @@
.assertSuccessWithOutputLines("foo", "parent b", "parent b", "x", "parent b")
.inspect(
codeInspector -> {
- if (enableHorizontalClassMerging) {
assertThat(codeInspector.clazz(ParentA.class), isPresent());
assertThat(codeInspector.clazz(ParentB.class), not(isPresent()));
assertThat(codeInspector.clazz(X.class), isPresent());
assertThat(codeInspector.clazz(Y.class), not(isPresent()));
- // TODO(b/165517236): Explicitly check classes have been merged.
- } else {
- assertThat(codeInspector.clazz(ParentA.class), isPresent());
- assertThat(codeInspector.clazz(ParentB.class), isPresent());
- assertThat(codeInspector.clazz(X.class), isPresent());
- assertThat(codeInspector.clazz(Y.class), isPresent());
- }
});
}
