Migrate MinifierClassSignatureTest and use diagnostics
Bug: 167145686
Change-Id: Ibb15b4fd786791b44172601b8617c20c58e8e8c1
diff --git a/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java b/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java
index 07dad43..b2ec374 100644
--- a/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java
@@ -4,13 +4,16 @@
package com.android.tools.r8.naming;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticOrigin;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
import static org.objectweb.asm.Opcodes.ACC_SUPER;
import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
@@ -20,15 +23,16 @@
import static org.objectweb.asm.Opcodes.RETURN;
import static org.objectweb.asm.Opcodes.V1_8;
-import com.android.tools.r8.DiagnosticsChecker;
-import com.android.tools.r8.R8Command;
-import com.android.tools.r8.StringConsumer;
+import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.ThrowingConsumer;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.function.Consumer;
import org.junit.Test;
@@ -64,15 +68,16 @@
String outerSignature = "<T:Ljava/lang/Object;>Ljava/lang/Object;";
String extendsInnerSignature = "LOuter<TT;>.Inner;";
String extendsInnerInnerSignature = "LOuter<TT;>.Inner.InnerInner;";
- private Backend backend;
- @Parameters(name = "Backend: {0}")
- public static Backend[] data() {
- return ToolHelper.getBackends();
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
- public MinifierClassSignatureTest(Backend backend) {
- this.backend = backend;
+ public MinifierClassSignatureTest(TestParameters parameters) {
+ this.parameters = parameters;
}
private byte[] dumpSimple(String classSignature) throws Exception {
@@ -298,34 +303,32 @@
public void runTest(
ImmutableMap<String, String> signatures,
- Consumer<DiagnosticsChecker> diagnostics,
- Consumer<CodeInspector> inspect)
+ Consumer<TestDiagnosticMessages> diagnostics,
+ ThrowingConsumer<CodeInspector, Exception> inspect)
throws Exception {
- DiagnosticsChecker checker = new DiagnosticsChecker();
- CodeInspector inspector =
- new CodeInspector(
- ToolHelper.runR8(
- R8Command.builder(checker)
- .addClassProgramData(dumpSimple(signatures.get("Simple")), Origin.unknown())
- .addClassProgramData(dumpBase(signatures.get("Base")), Origin.unknown())
- .addClassProgramData(dumpOuter(signatures.get("Outer")), Origin.unknown())
- .addClassProgramData(dumpInner(signatures.get("Outer$Inner")), Origin.unknown())
- .addClassProgramData(
- dumpExtendsInner(signatures.get("Outer$ExtendsInner")), Origin.unknown())
- .addClassProgramData(
- dumpInnerInner(signatures.get("Outer$Inner$InnerInner")), Origin.unknown())
- .addClassProgramData(
- dumpExtendsInnerInner(signatures.get("Outer$Inner$ExtendsInnerInner")),
- Origin.unknown())
- .addProguardConfiguration(
- ImmutableList.of(
- "-keepattributes InnerClasses,EnclosingMethod,Signature",
- "-keep,allowobfuscation class **"),
- Origin.unknown())
- .setProgramConsumer(emptyConsumer(backend))
- .addLibraryFiles(runtimeJar(backend))
- .setProguardMapConsumer(StringConsumer.emptyConsumer())
- .build()));
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(dumpSimple(signatures.get("Simple")))
+ .addProgramClassFileData(dumpBase(signatures.get("Base")))
+ .addProgramClassFileData(dumpOuter(signatures.get("Outer")))
+ .addProgramClassFileData(dumpInner(signatures.get("Outer$Inner")))
+ .addProgramClassFileData(dumpExtendsInner(signatures.get("Outer$ExtendsInner")))
+ .addProgramClassFileData(dumpInnerInner(signatures.get("Outer$Inner$InnerInner")))
+ .addProgramClassFileData(
+ dumpExtendsInnerInner(signatures.get("Outer$Inner$ExtendsInnerInner")))
+ .addKeepAttributes(
+ ProguardKeepAttributes.INNER_CLASSES,
+ ProguardKeepAttributes.ENCLOSING_METHOD,
+ ProguardKeepAttributes.SIGNATURE)
+ .addKeepAllClassesRuleWithAllowObfuscation()
+ .allowDiagnosticMessages()
+ .compile();
+
+ compileResult.assertNoInfoMessages();
+ compileResult.assertNoErrorMessages();
+
+ CodeInspector inspector = compileResult.inspector();
+
// All classes are kept, and renamed.
assertThat(inspector.clazz("Simple"), isPresentAndRenamed());
assertThat(inspector.clazz("Base"), isPresentAndRenamed());
@@ -360,26 +363,20 @@
inspector.clazz("Outer$Inner$ExtendsInnerInner").getOriginalSignatureAttribute());
}
- diagnostics.accept(checker);
- inspect.accept(inspector);
+ diagnostics.accept(compileResult.getDiagnosticMessages());
+ compileResult.inspect(inspect);
}
- private void testSingleClass(String name, String signature,
- Consumer<DiagnosticsChecker> diagnostics,
- Consumer<CodeInspector> inspector)
+ private void testSingleClass(
+ String name,
+ String signature,
+ Consumer<TestDiagnosticMessages> diagnostics,
+ ThrowingConsumer<CodeInspector, Exception> inspector)
throws Exception {
ImmutableMap<String, String> signatures = ImmutableMap.of(name, signature);
runTest(signatures, diagnostics, inspector);
}
- private void isOriginUnknown(Origin origin) {
- assertSame(Origin.unknown(), origin);
- }
-
- private void noWarnings(DiagnosticsChecker checker) {
- assertEquals(0, checker.warnings.size());
- }
-
private void noInspection(CodeInspector inspector) {
}
@@ -391,165 +388,237 @@
@Test
public void originalJavacSignatures() throws Exception {
// Test using the signatures generated by javac.
- runTest(ImmutableMap.of(), this::noWarnings, this::noInspection);
+ runTest(ImmutableMap.of(), TestDiagnosticMessages::assertNoWarnings, this::noInspection);
}
@Test
public void classSignature_empty() throws Exception {
- testSingleClass("Outer", "", this::noWarnings, inspector -> {
- ClassSubject outer = inspector.clazz("Outer");
- assertNull(outer.getFinalSignatureAttribute());
- assertNull(outer.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer",
+ "",
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ ClassSubject outer = inspector.clazz("Outer");
+ assertNull(outer.getFinalSignatureAttribute());
+ assertNull(outer.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureOuter_valid() throws Exception {
// class Outer<T extends Simple> extends Base<T>
String signature = "<T:LSimple;>LBase<TT;>;";
- testSingleClass("Outer", signature, this::noWarnings, inspector -> {
- ClassSubject outer = inspector.clazz("Outer");
- ClassSubject simple = inspector.clazz("Simple");
- ClassSubject base = inspector.clazz("Base");
- String baseDescriptorWithoutSemicolon =
- base.getFinalDescriptor().substring(0, base.getFinalDescriptor().length() - 1);
- String minifiedSignature =
- "<T:" + simple.getFinalDescriptor() + ">" + baseDescriptorWithoutSemicolon + "<TT;>;";
- assertEquals(minifiedSignature, outer.getFinalSignatureAttribute());
- assertEquals(signature, outer.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer",
+ signature,
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ ClassSubject outer = inspector.clazz("Outer");
+ ClassSubject simple = inspector.clazz("Simple");
+ ClassSubject base = inspector.clazz("Base");
+ String baseDescriptorWithoutSemicolon =
+ base.getFinalDescriptor().substring(0, base.getFinalDescriptor().length() - 1);
+ String minifiedSignature =
+ "<T:" + simple.getFinalDescriptor() + ">" + baseDescriptorWithoutSemicolon + "<TT;>;";
+ assertEquals(minifiedSignature, outer.getFinalSignatureAttribute());
+ assertEquals(signature, outer.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureExtendsInner_valid() throws Exception {
String signature = "LOuter<TT;>.Inner;";
- testSingleClass("Outer$ExtendsInner", signature, this::noWarnings, inspector -> {
- ClassSubject extendsInner = inspector.clazz("Outer$ExtendsInner");
- ClassSubject outer = inspector.clazz("Outer");
- ClassSubject inner = inspector.clazz("Outer$Inner");
- String outerDescriptorWithoutSemicolon =
- outer.getFinalDescriptor().substring(0, outer.getFinalDescriptor().length() - 1);
- String innerFinalDescriptor = inner.getFinalDescriptor();
- String innerLastPart =
- innerFinalDescriptor.substring(innerFinalDescriptor.indexOf("$") + 1);
- String minifiedSignature = outerDescriptorWithoutSemicolon + "<TT;>." + innerLastPart;
- assertEquals(minifiedSignature, extendsInner.getFinalSignatureAttribute());
- assertEquals(signature, extendsInner.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer$ExtendsInner",
+ signature,
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ ClassSubject extendsInner = inspector.clazz("Outer$ExtendsInner");
+ ClassSubject outer = inspector.clazz("Outer");
+ ClassSubject inner = inspector.clazz("Outer$Inner");
+ String outerDescriptorWithoutSemicolon =
+ outer.getFinalDescriptor().substring(0, outer.getFinalDescriptor().length() - 1);
+ String innerFinalDescriptor = inner.getFinalDescriptor();
+ String innerLastPart =
+ innerFinalDescriptor.substring(innerFinalDescriptor.indexOf("$") + 1);
+ String minifiedSignature = outerDescriptorWithoutSemicolon + "<TT;>." + innerLastPart;
+ assertEquals(minifiedSignature, extendsInner.getFinalSignatureAttribute());
+ assertEquals(signature, extendsInner.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureOuter_classNotFound() throws Exception {
String signature = "<T:LNotFound;>LAlsoNotFound;";
- testSingleClass("Outer", signature, this::noWarnings, inspector -> {
- assertThat(inspector.clazz("NotFound"), not(isPresent()));
- ClassSubject outer = inspector.clazz("Outer");
- assertEquals(signature, outer.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer",
+ signature,
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ assertThat(inspector.clazz("NotFound"), not(isPresent()));
+ ClassSubject outer = inspector.clazz("Outer");
+ assertEquals(signature, outer.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureExtendsInner_innerClassNotFound() throws Exception {
String signature = "LOuter<TT;>.NotFound;";
- testSingleClass("Outer$ExtendsInner", signature, this::noWarnings, inspector -> {
- assertThat(inspector.clazz("NotFound"), not(isPresent()));
- ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
- assertEquals(signature, outer.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer$ExtendsInner",
+ signature,
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ assertThat(inspector.clazz("NotFound"), not(isPresent()));
+ ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
+ assertEquals(signature, outer.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureExtendsInner_outerAndInnerClassNotFound() throws Exception {
String signature = "LNotFound<TT;>.AlsoNotFound;";
- testSingleClass("Outer$ExtendsInner", signature, this::noWarnings, inspector -> {
- assertThat(inspector.clazz("NotFound"), not(isPresent()));
- ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
- assertEquals(signature, outer.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer$ExtendsInner",
+ signature,
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ assertThat(inspector.clazz("NotFound"), not(isPresent()));
+ ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
+ assertEquals(signature, outer.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureExtendsInner_nestedInnerClassNotFound() throws Exception {
String signature = "LOuter<TT;>.Inner.NotFound;";
- testSingleClass("Outer$ExtendsInner", signature, this::noWarnings, inspector -> {
- assertThat(inspector.clazz("NotFound"), not(isPresent()));
- ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
- assertEquals(signature, outer.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer$ExtendsInner",
+ signature,
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ assertThat(inspector.clazz("NotFound"), not(isPresent()));
+ ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
+ assertEquals(signature, outer.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureExtendsInner_multipleMestedInnerClassesNotFound() throws Exception {
String signature = "LOuter<TT;>.NotFound.AlsoNotFound;";
- testSingleClass("Outer$ExtendsInner", signature, this::noWarnings, inspector -> {
- assertThat(inspector.clazz("NotFound"), not(isPresent()));
- ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
- assertEquals(signature, outer.getOriginalSignatureAttribute());
- });
+ testSingleClass(
+ "Outer$ExtendsInner",
+ signature,
+ TestDiagnosticMessages::assertNoWarnings,
+ inspector -> {
+ assertThat(inspector.clazz("NotFound"), not(isPresent()));
+ ClassSubject outer = inspector.clazz("Outer$ExtendsInner");
+ assertEquals(signature, outer.getOriginalSignatureAttribute());
+ });
}
@Test
public void classSignatureOuter_invalid() throws Exception {
- testSingleClass("Outer", "X", diagnostics -> {
- assertEquals(1, diagnostics.warnings.size());
- DiagnosticsChecker.checkDiagnostic(diagnostics.warnings.get(0), this::isOriginUnknown,
- "Invalid signature 'X' for class Outer", "Expected L at position 1");
- }, inspector -> noSignatureAttribute(inspector.clazz("Outer")));
+ testSingleClass(
+ "Outer",
+ "X",
+ diagnostics -> {
+ diagnostics.assertWarningsCount(1);
+ diagnostics.assertAllWarningsMatch(
+ allOf(
+ diagnosticMessage(containsString("Invalid signature 'X' for class Outer")),
+ diagnosticMessage(containsString("Expected L at position 1")),
+ diagnosticOrigin(Origin.unknown())));
+ },
+ inspector -> noSignatureAttribute(inspector.clazz("Outer")));
}
@Test
public void classSignatureOuter_invalidEnd() throws Exception {
- testSingleClass("Outer", "<L", diagnostics -> {
- assertEquals(1, diagnostics.warnings.size());
- DiagnosticsChecker.checkDiagnostic(diagnostics.warnings.get(0), this::isOriginUnknown,
- "Invalid signature '<L' for class Outer", "Unexpected end of signature at position 3");
- }, inspector -> noSignatureAttribute(inspector.clazz("Outer")));
+ testSingleClass(
+ "Outer",
+ "<L",
+ diagnostics -> {
+ diagnostics.assertWarningsCount(1);
+ diagnostics.assertAllWarningsMatch(
+ allOf(
+ diagnosticMessage(containsString("Invalid signature '<L' for class Outer")),
+ diagnosticMessage(containsString("Unexpected end of signature at position 3")),
+ diagnosticOrigin(Origin.unknown())));
+ },
+ inspector -> noSignatureAttribute(inspector.clazz("Outer")));
}
@Test
public void classSignatureExtendsInner_invalid() throws Exception {
- testSingleClass("Outer$ExtendsInner", "X", diagnostics -> {
- assertEquals(1, diagnostics.warnings.size());
- DiagnosticsChecker.checkDiagnostic(diagnostics.warnings.get(0), this::isOriginUnknown,
- "Invalid signature 'X' for class Outer$ExtendsInner", "Expected L at position 1");
- }, inspector -> noSignatureAttribute(inspector.clazz("Outer$ExtendsInner")));
+ testSingleClass(
+ "Outer$ExtendsInner",
+ "X",
+ diagnostics -> {
+ diagnostics.assertWarningsCount(1);
+ diagnostics.assertAllWarningsMatch(
+ allOf(
+ diagnosticMessage(
+ containsString("Invalid signature 'X' for class Outer$ExtendsInner")),
+ diagnosticMessage(containsString("Expected L at position 1")),
+ diagnosticOrigin(Origin.unknown())));
+ },
+ inspector -> noSignatureAttribute(inspector.clazz("Outer$ExtendsInner")));
}
@Test
public void classSignatureExtendsInnerInner_invalid() throws Exception {
- testSingleClass("Outer$Inner$ExtendsInnerInner", "X", diagnostics -> {
- assertEquals(1, diagnostics.warnings.size());
- DiagnosticsChecker.checkDiagnostic(diagnostics.warnings.get(0), this::isOriginUnknown,
- "Invalid signature 'X' for class Outer$Inner$ExtendsInnerInner",
- "Expected L at position 1");
- }, inspector -> noSignatureAttribute(inspector.clazz("Outer$Inner$ExtendsInnerInner")));
+ testSingleClass(
+ "Outer$Inner$ExtendsInnerInner",
+ "X",
+ diagnostics -> {
+ diagnostics.assertWarningsCount(1);
+ diagnostics.assertAllWarningsMatch(
+ allOf(
+ diagnosticMessage(
+ containsString(
+ "Invalid signature 'X' for class Outer$Inner$ExtendsInnerInner")),
+ diagnosticMessage(containsString("Expected L at position 1")),
+ diagnosticOrigin(Origin.unknown())));
+ },
+ inspector -> noSignatureAttribute(inspector.clazz("Outer$Inner$ExtendsInnerInner")));
}
@Test
public void multipleWarnings() throws Exception {
- runTest(ImmutableMap.of(
- "Outer", "X",
- "Outer$ExtendsInner", "X",
- "Outer$Inner$ExtendsInnerInner", "X"), diagnostics -> {
- assertEquals(3, diagnostics.warnings.size());
- }, inspector -> {
- noSignatureAttribute(inspector.clazz("Outer"));
- noSignatureAttribute(inspector.clazz("Outer$ExtendsInner"));
- noSignatureAttribute(inspector.clazz("Outer$Inner$ExtendsInnerInner"));
- });
+ runTest(
+ ImmutableMap.of(
+ "Outer", "X",
+ "Outer$ExtendsInner", "X",
+ "Outer$Inner$ExtendsInnerInner", "X"),
+ diagnostics -> {
+ diagnostics.assertWarningsCount(3);
+ },
+ inspector -> {
+ noSignatureAttribute(inspector.clazz("Outer"));
+ noSignatureAttribute(inspector.clazz("Outer$ExtendsInner"));
+ noSignatureAttribute(inspector.clazz("Outer$Inner$ExtendsInnerInner"));
+ });
}
+
@Test
public void regress80029761() throws Exception {
String signature = "LOuter<TT;>.com/example/Inner;";
- testSingleClass("Outer$ExtendsInner", signature, diagnostics -> {
- assertEquals(1, diagnostics.warnings.size());
- DiagnosticsChecker.checkDiagnostic(
- diagnostics.warnings.get(0),
- this::isOriginUnknown,
- "Invalid signature '" + signature + "' for class Outer$ExtendsInner",
- "Expected ; at position 16");
- }, inspector -> {
- noSignatureAttribute(inspector.clazz("Outer$ExtendsInner"));
- });
+ testSingleClass(
+ "Outer$ExtendsInner",
+ signature,
+ diagnostics -> {
+ diagnostics.assertWarningsCount(1);
+ diagnostics.assertAllWarningsMatch(
+ allOf(
+ diagnosticMessage(
+ containsString(
+ "Invalid signature '" + signature + "' for class Outer$ExtendsInner")),
+ diagnosticMessage(containsString("Expected ; at position 16")),
+ diagnosticOrigin(Origin.unknown())));
+ },
+ inspector -> {
+ noSignatureAttribute(inspector.clazz("Outer$ExtendsInner"));
+ });
}
}
