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