Add a test for -printconfiguration using relative paths
To do this easily, this CL also introduces the necessary testing APIs for running R8 externally. To this end, the CL also updates the test BootstrapCurrentEqualityTest to use the new testing API.
Bug: 122363328
Change-Id: I3c0f0078d058c15e85417b76918bfa1ffcc5d295
diff --git a/src/test/java/com/android/tools/r8/D8TestCompileResult.java b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
index 79fb293..765978b 100644
--- a/src/test/java/com/android/tools/r8/D8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/D8TestCompileResult.java
@@ -23,7 +23,7 @@
}
@Override
- public D8TestRunResult createRunResult(AndroidApp app, ProcessResult result) {
+ public D8TestRunResult createRunResult(ProcessResult result) {
return new D8TestRunResult(app, result);
}
}
diff --git a/src/test/java/com/android/tools/r8/DXTestCompileResult.java b/src/test/java/com/android/tools/r8/DXTestCompileResult.java
index da6a17a..dc219ec 100644
--- a/src/test/java/com/android/tools/r8/DXTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/DXTestCompileResult.java
@@ -24,7 +24,7 @@
}
@Override
- public DXTestRunResult createRunResult(AndroidApp app, ProcessResult result) {
+ public DXTestRunResult createRunResult(ProcessResult result) {
return new DXTestRunResult(app, result);
}
}
diff --git a/src/test/java/com/android/tools/r8/ExternalR8TestBuilder.java b/src/test/java/com/android/tools/r8/ExternalR8TestBuilder.java
new file mode 100644
index 0000000..da46d60
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ExternalR8TestBuilder.java
@@ -0,0 +1,182 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8;
+
+import static com.android.tools.r8.ToolHelper.getJavaExecutable;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.R8Command.Builder;
+import com.android.tools.r8.TestBase.Backend;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.InternalOptions;
+import com.google.common.base.Charsets;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+// The type arguments R8Command, Builder is not relevant for running external R8.
+public class ExternalR8TestBuilder
+ extends TestShrinkerBuilder<
+ R8Command,
+ Builder,
+ ExternalR8TestCompileResult,
+ ExternalR8TestRunResult,
+ ExternalR8TestBuilder> {
+
+ // The r8.jar to run.
+ private Path r8jar = ToolHelper.R8_JAR;
+
+ // Ordered list of program jar entries.
+ private final List<Path> programJars = new ArrayList<>();
+
+ // Ordered list of library jar entries.
+ private final List<Path> libJars = new ArrayList<>();
+
+ // Proguard configuration file lines.
+ private final List<String> config = new ArrayList<>();
+
+ private ExternalR8TestBuilder(TestState state, Builder builder, Backend backend) {
+ super(state, builder, backend);
+ }
+
+ public static ExternalR8TestBuilder create(TestState state, Backend backend) {
+ return new ExternalR8TestBuilder(state, R8Command.builder(), backend);
+ }
+
+ @Override
+ ExternalR8TestBuilder self() {
+ return this;
+ }
+
+ @Override
+ ExternalR8TestCompileResult internalCompile(
+ Builder builder, Consumer<InternalOptions> optionsConsumer, Supplier<AndroidApp> app)
+ throws CompilationFailedException {
+ try {
+ Path outputFolder = getState().getNewTempFolder();
+ Path outputJar = outputFolder.resolve("output.jar");
+ Path proguardConfigFile = outputFolder.resolve("proguard-config.txt");
+ Path proguardMapFile = outputFolder.resolve("output.jar.map");
+
+ FileUtils.writeTextFile(proguardConfigFile, config);
+
+ List<String> command = new ArrayList<>();
+ Collections.addAll(
+ command,
+ getJavaExecutable(),
+ "-cp",
+ r8jar.toAbsolutePath().toString(),
+ R8.class.getTypeName(),
+ "--output",
+ outputJar.toAbsolutePath().toString(),
+ "--pg-conf",
+ proguardConfigFile.toAbsolutePath().toString(),
+ "--pg-map-output",
+ proguardMapFile.toString(),
+ backend == Backend.CF ? "--classfile" : "--dex",
+ builder.getMode() == CompilationMode.DEBUG ? "--debug" : "--release");
+ if (libJars.isEmpty()) {
+ command.add("--lib");
+ command.add(TestBase.runtimeJar(backend).toAbsolutePath().toString());
+ } else {
+ for (Path libJar : libJars) {
+ command.add("--lib");
+ command.add(libJar.toAbsolutePath().toString());
+ }
+ }
+ command.addAll(programJars.stream().map(Path::toString).collect(Collectors.toList()));
+
+ ProcessBuilder processBuilder = new ProcessBuilder(command);
+ ProcessResult processResult = ToolHelper.runProcess(processBuilder);
+ assertEquals(processResult.stderr, 0, processResult.exitCode);
+ String proguardMap =
+ proguardMapFile.toFile().exists()
+ ? FileUtils.readTextFile(proguardMapFile, Charsets.UTF_8)
+ : "";
+ return new ExternalR8TestCompileResult(getState(), outputJar, processResult, proguardMap);
+ } catch (IOException e) {
+ throw new CompilationFailedException(e);
+ }
+ }
+
+ @Override
+ public ExternalR8TestBuilder addProgramClasses(Collection<Class<?>> classes) {
+ // Adding a collection of classes will build a jar of exactly those classes so that no other
+ // classes are made available via a too broad classpath directory.
+ try {
+ Path programJar = getState().getNewTempFolder().resolve("input.jar");
+ ClassFileConsumer inputConsumer = new ClassFileConsumer.ArchiveConsumer(programJar);
+ for (Class<?> clazz : classes) {
+ String descriptor = DescriptorUtils.javaTypeToDescriptor(clazz.getName());
+ inputConsumer.accept(ByteDataView.of(ToolHelper.getClassAsBytes(clazz)), descriptor, null);
+ }
+ inputConsumer.finished(null);
+ programJars.add(programJar);
+ return self();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public ExternalR8TestBuilder addProgramFiles(Collection<Path> files) {
+ for (Path file : files) {
+ if (FileUtils.isJarFile(file)) {
+ programJars.add(file);
+ } else {
+ throw new Unimplemented("No support for adding paths directly");
+ }
+ }
+ return self();
+ }
+
+ @Override
+ public ExternalR8TestBuilder addProgramClassFileData(Collection<byte[]> classes) {
+ throw new Unimplemented("No support for adding classfile data directly");
+ }
+
+ @Override
+ public ExternalR8TestBuilder addLibraryFiles(Collection<Path> files) {
+ libJars.addAll(files);
+ return self();
+ }
+
+ @Override
+ public ExternalR8TestBuilder addKeepRuleFiles(List<Path> files) {
+ try {
+ for (Path file : files) {
+ config.addAll(FileUtils.readAllLines(file));
+ }
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ return self();
+ }
+
+ @Override
+ public ExternalR8TestBuilder addKeepRules(Collection<String> rules) {
+ config.addAll(rules);
+ return self();
+ }
+
+ public ExternalR8TestBuilder useR8WithRelocatedDeps() {
+ return useProvidedR8(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR);
+ }
+
+ public ExternalR8TestBuilder useProvidedR8(Path r8jar) {
+ this.r8jar = r8jar;
+ return self();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java b/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
new file mode 100644
index 0000000..4f1058e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ExternalR8TestCompileResult.java
@@ -0,0 +1,61 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8;
+
+import com.android.tools.r8.TestBase.Backend;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.concurrent.ExecutionException;
+
+public class ExternalR8TestCompileResult extends TestCompileResult<ExternalR8TestRunResult> {
+
+ private final Path outputJar;
+ private final ProcessResult processResult;
+ private final String proguardMap;
+
+ protected ExternalR8TestCompileResult(
+ TestState state, Path outputJar, ProcessResult processResult, String proguardMap) {
+ super(state, AndroidApp.builder().addProgramFiles(outputJar).build());
+ assert processResult.exitCode == 0;
+ this.outputJar = outputJar;
+ this.processResult = processResult;
+ this.proguardMap = proguardMap;
+ }
+
+ public Path outputJar() {
+ return outputJar;
+ }
+
+ public String stdout() {
+ return processResult.stdout;
+ }
+
+ public String stderr() {
+ return processResult.stdout;
+ }
+
+ @Override
+ public Backend getBackend() {
+ return null;
+ }
+
+ @Override
+ public TestDiagnosticMessages getDiagnosticMessages() {
+ throw new UnsupportedOperationException("No diagnostics messages from external R8");
+ }
+
+ @Override
+ public CodeInspector inspector() throws IOException, ExecutionException {
+ return new CodeInspector(app, proguardMap);
+ }
+
+ @Override
+ protected ExternalR8TestRunResult createRunResult(ProcessResult result) {
+ return new ExternalR8TestRunResult(app, outputJar, proguardMap, result);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ExternalR8TestRunResult.java b/src/test/java/com/android/tools/r8/ExternalR8TestRunResult.java
new file mode 100644
index 0000000..f301b78
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ExternalR8TestRunResult.java
@@ -0,0 +1,44 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8;
+
+import static org.junit.Assert.assertNotNull;
+
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.concurrent.ExecutionException;
+
+public class ExternalR8TestRunResult extends TestRunResult<ExternalR8TestRunResult> {
+
+ private final Path outputJar;
+ private final String proguardMap;
+
+ public ExternalR8TestRunResult(
+ AndroidApp app, Path outputJar, String proguardMap, ProcessResult result) {
+ super(app, result);
+ this.outputJar = outputJar;
+ this.proguardMap = proguardMap;
+ }
+
+ public Path outputJar() {
+ return outputJar;
+ }
+
+ @Override
+ protected ExternalR8TestRunResult self() {
+ return this;
+ }
+
+ @Override
+ public CodeInspector inspector() throws IOException, ExecutionException {
+ // See comment in base class.
+ assertSuccess();
+ assertNotNull(app);
+ return new CodeInspector(app, proguardMap);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java b/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
index 4ea8953..e8ed9a8 100644
--- a/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/ProguardTestCompileResult.java
@@ -26,7 +26,7 @@
@Override
public TestDiagnosticMessages getDiagnosticMessages() {
- throw new UnsupportedOperationException("No diagnostics messages from dx");
+ throw new UnsupportedOperationException("No diagnostics messages from Proguard");
}
@Override
@@ -35,7 +35,7 @@
}
@Override
- public ProguardTestRunResult createRunResult(AndroidApp app, ProcessResult result) {
+ public ProguardTestRunResult createRunResult(ProcessResult result) {
return new ProguardTestRunResult(app, result, proguardMap);
}
}
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index ef5bfb1..461a761 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -51,7 +51,7 @@
}
@Override
- public R8TestRunResult createRunResult(AndroidApp app, ProcessResult result) {
+ public R8TestRunResult createRunResult(ProcessResult result) {
return new R8TestRunResult(app, result, proguardMap, this::graphInspector);
}
}
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 0783413..e0baab1 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -83,6 +83,10 @@
return R8TestBuilder.create(new TestState(temp), backend, R8Mode.Compat);
}
+ public static ExternalR8TestBuilder testForExternalR8(TemporaryFolder temp, Backend backend) {
+ return ExternalR8TestBuilder.create(new TestState(temp), backend);
+ }
+
public static D8TestBuilder testForD8(TemporaryFolder temp) {
return D8TestBuilder.create(new TestState(temp));
}
@@ -107,6 +111,10 @@
return testForR8Compat(temp, backend);
}
+ public ExternalR8TestBuilder testForExternalR8(Backend backend) {
+ return testForExternalR8(temp, backend);
+ }
+
public D8TestBuilder testForD8() {
return testForD8(temp);
}
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
index 4a31320..4fd6515 100644
--- a/src/test/java/com/android/tools/r8/TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -38,7 +38,7 @@
public abstract TestDiagnosticMessages getDiagnosticMessages();
- protected abstract RR createRunResult(AndroidApp add, ProcessResult result);
+ protected abstract RR createRunResult(ProcessResult result);
public RR run(Class<?> mainClass) throws IOException {
return run(mainClass.getTypeName());
@@ -162,14 +162,14 @@
Path out = state.getNewTempFolder().resolve("out.zip");
app.writeToZip(out, OutputMode.ClassFile);
ProcessResult result = ToolHelper.runJava(out, mainClass);
- return createRunResult(app, result);
+ return createRunResult(result);
}
private RR runArt(String mainClass) throws IOException {
Path out = state.getNewTempFolder().resolve("out.zip");
app.writeToZip(out, OutputMode.DexIndexed);
ProcessResult result = ToolHelper.runArtRaw(out.toString(), mainClass);
- return createRunResult(app, result);
+ return createRunResult(result);
}
public Dex2OatTestRunResult runDex2Oat() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/cf/BootstrapCurrentEqualityTest.java b/src/test/java/com/android/tools/r8/cf/BootstrapCurrentEqualityTest.java
index a0cd03d..aeeb0ec 100644
--- a/src/test/java/com/android/tools/r8/cf/BootstrapCurrentEqualityTest.java
+++ b/src/test/java/com/android/tools/r8/cf/BootstrapCurrentEqualityTest.java
@@ -10,14 +10,13 @@
import com.android.tools.r8.ArchiveClassFileProvider;
import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.ExternalR8TestCompileResult;
import com.android.tools.r8.OutputMode;
import com.android.tools.r8.R8;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.utils.FileUtils;
-import com.google.common.base.Charsets;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
@@ -34,12 +33,11 @@
import org.junit.rules.TemporaryFolder;
/**
- * This test relies on a freshly built builds/libs/r8lib_with_deps.jar. If this test fails
- * remove build directory and rebuild r8lib_with_deps by calling test.py or gradle r8libWithdeps.
+ * This test relies on a freshly built build/libs/r8lib_with_deps.jar. If this test fails remove
+ * build directory and rebuild r8lib_with_deps by calling test.py or gradle r8libWithdeps.
*/
public class BootstrapCurrentEqualityTest extends TestBase {
- private static final String R8_NAME = "com.android.tools.r8.R8";
private static final Path MAIN_KEEP = Paths.get("src/main/keep.txt");
private static final String HELLO_NAME = "hello.Hello";
@@ -47,24 +45,6 @@
"-keep class " + HELLO_NAME + " {", " public static void main(...);", "}",
};
- private static class R8Result {
-
- final ProcessResult processResult;
- final Path outputJar;
- final String pgMap;
-
- R8Result(ProcessResult processResult, Path outputJar, String pgMap) {
- this.processResult = processResult;
- this.outputJar = outputJar;
- this.pgMap = pgMap;
- }
-
- @Override
- public String toString() {
- return processResult.toString() + "\n\n" + pgMap;
- }
- }
-
private static Path r8R8Debug;
private static Path r8R8Release;
@@ -74,22 +54,22 @@
@BeforeClass
public static void beforeAll() throws Exception {
- r8R8Debug = compileR8("--debug");
- r8R8Release = compileR8("--release");
+ r8R8Debug = compileR8(CompilationMode.DEBUG);
+ r8R8Release = compileR8(CompilationMode.RELEASE);
}
- private static Path compileR8(String mode) throws Exception {
+ private static Path compileR8(CompilationMode mode) throws Exception {
// Run R8 on r8.jar.
Path jar;
if (testExternal) {
- R8Result output =
- runExternalR8(
- ToolHelper.R8_WITH_RELOCATED_DEPS_JAR,
- ToolHelper.R8_WITH_RELOCATED_DEPS_JAR,
- testFolder.newFolder().toPath(),
- MAIN_KEEP,
- mode);
- jar = output.outputJar;
+ jar =
+ testForExternalR8(newTempFolder(), Backend.CF)
+ .useR8WithRelocatedDeps()
+ .addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_JAR)
+ .addKeepRuleFiles(MAIN_KEEP)
+ .setMode(mode)
+ .compile()
+ .outputJar();
} else {
jar = testFolder.newFolder().toPath().resolve("out.zip");
R8.run(
@@ -124,66 +104,48 @@
private void compareR8(Path program, ProcessResult runResult, String[] keep, String... args)
throws Exception {
- R8Result runR8Debug =
- runExternalR8(
- ToolHelper.R8_WITH_RELOCATED_DEPS_JAR,
- program,
- temp.newFolder().toPath(),
- keep,
- "--debug");
- assertEquals(runResult.toString(), ToolHelper.runJava(runR8Debug.outputJar, args).toString());
- R8Result runR8Release =
- runExternalR8(
- ToolHelper.R8_WITH_RELOCATED_DEPS_JAR,
- program,
- temp.newFolder().toPath(),
- keep,
- "--release");
- assertEquals(runResult.toString(), ToolHelper.runJava(runR8Release.outputJar, args).toString());
- RunR8AndCheck(r8R8Debug, program, runR8Debug, keep, "--debug");
- RunR8AndCheck(r8R8Debug, program, runR8Release, keep, "--release");
- RunR8AndCheck(r8R8Release, program, runR8Debug, keep, "--debug");
- RunR8AndCheck(r8R8Release, program, runR8Release, keep, "--release");
+ ExternalR8TestCompileResult runR8Debug =
+ testForExternalR8(newTempFolder(), Backend.CF)
+ .useR8WithRelocatedDeps()
+ .addProgramFiles(program)
+ .addKeepRules(keep)
+ .setMode(CompilationMode.DEBUG)
+ .compile();
+ assertEquals(runResult.toString(), ToolHelper.runJava(runR8Debug.outputJar(), args).toString());
+ ExternalR8TestCompileResult runR8Release =
+ testForExternalR8(newTempFolder(), Backend.CF)
+ .useR8WithRelocatedDeps()
+ .addProgramFiles(program)
+ .addKeepRules(keep)
+ .setMode(CompilationMode.RELEASE)
+ .compile();
+ assertEquals(
+ runResult.toString(), ToolHelper.runJava(runR8Release.outputJar(), args).toString());
+ RunR8AndCheck(r8R8Debug, program, runR8Debug, keep, CompilationMode.DEBUG);
+ RunR8AndCheck(r8R8Debug, program, runR8Release, keep, CompilationMode.RELEASE);
+ RunR8AndCheck(r8R8Release, program, runR8Debug, keep, CompilationMode.DEBUG);
+ RunR8AndCheck(r8R8Release, program, runR8Release, keep, CompilationMode.RELEASE);
}
- private void RunR8AndCheck(Path r8, Path program, R8Result result, String[] keep, String mode)
+ private void RunR8AndCheck(
+ Path r8,
+ Path program,
+ ExternalR8TestCompileResult result,
+ String[] keep,
+ CompilationMode mode)
throws Exception {
- R8Result runR8R8 = runExternalR8(r8, program, temp.newFolder().toPath(), keep, mode);
+ ExternalR8TestCompileResult runR8R8 =
+ testForExternalR8(newTempFolder(), Backend.CF)
+ .useProvidedR8(r8)
+ .addProgramFiles(program)
+ .addKeepRules(keep)
+ .setMode(mode)
+ .compile();
// Check that the process outputs (exit code, stdout, stderr) are the same.
- assertEquals(result.toString(), runR8R8.toString());
+ assertEquals(result.stdout(), runR8R8.stdout());
+ assertEquals(result.stderr(), runR8R8.stderr());
// Check that the output jars are the same.
- assertProgramsEqual(result.outputJar, runR8R8.outputJar);
- }
-
- private static R8Result runExternalR8(
- Path r8Jar, Path inputJar, Path output, String[] keepRules, String mode) throws Exception {
- Path pgConfigFile = output.resolve("keep.rules");
- FileUtils.writeTextFile(pgConfigFile, keepRules);
- return runExternalR8(r8Jar, inputJar, output, pgConfigFile, mode);
- }
-
- private static R8Result runExternalR8(
- Path r8Jar, Path inputJar, Path output, Path keepRules, String mode) throws Exception {
- Path outputJar = output.resolve("output.jar");
- Path pgMapFile = output.resolve("output.jar.map");
- ProcessResult processResult =
- ToolHelper.runJava(
- r8Jar,
- R8_NAME,
- "--lib",
- ToolHelper.JAVA_8_RUNTIME,
- "--classfile",
- inputJar.toString(),
- "--output",
- outputJar.toString(),
- "--pg-conf",
- keepRules.toString(),
- mode,
- "--pg-map-output",
- pgMapFile.toString());
- assertEquals(processResult.stderr, 0, processResult.exitCode);
- String pgMap = FileUtils.readTextFile(pgMapFile, Charsets.UTF_8);
- return new R8Result(processResult, outputJar, pgMap);
+ assertProgramsEqual(result.outputJar(), runR8R8.outputJar());
}
private static void assertProgramsEqual(Path expectedJar, Path actualJar) throws Exception {
@@ -234,4 +196,10 @@
throws Exception {
return toByteArray(inputJar.getProgramResource(descriptor).getByteStream());
}
+
+ private static TemporaryFolder newTempFolder() throws IOException {
+ TemporaryFolder tempFolder = new TemporaryFolder(testFolder.newFolder());
+ tempFolder.create();
+ return tempFolder;
+ }
}
diff --git a/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java b/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
index 7621522..f0031d2 100644
--- a/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/PrintConfigurationTest.java
@@ -6,8 +6,10 @@
import static org.junit.Assert.assertEquals;
+import com.android.tools.r8.ExternalR8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.StringUtils;
import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
@@ -15,19 +17,38 @@
class PrintConfigurationTestClass {
- public static void main(String[] args) {
-
- }
+ public static void main(String[] args) {}
}
public class PrintConfigurationTest extends TestBase {
+
@Test
- public void testSingleCOnfiguration() throws Exception {
- Class mainClass = PrintConfigurationTestClass.class;
- String proguardConfig = keepMainProguardConfiguration(mainClass);
+ public void testSingleConfigurationWithAbsolutePath() throws Exception {
Path printConfigurationFile = temp.newFile().toPath();
- proguardConfig += "\n-printconfiguration " + printConfigurationFile.toString();
- compileWithR8(ImmutableList.of(mainClass), proguardConfig);
+ String proguardConfig =
+ StringUtils.lines(
+ keepMainProguardConfiguration(PrintConfigurationTestClass.class),
+ "-printconfiguration " + printConfigurationFile);
+ testForR8(Backend.DEX)
+ .addProgramClasses(PrintConfigurationTestClass.class)
+ .addKeepRules(proguardConfig)
+ .compile();
+ assertEquals(proguardConfig, FileUtils.readTextFile(printConfigurationFile, Charsets.UTF_8));
+ }
+
+ @Test
+ public void testSingleConfigurationWithRelativePath() throws Exception {
+ String proguardConfig =
+ StringUtils.lines(
+ keepMainProguardConfiguration(PrintConfigurationTestClass.class),
+ "-printconfiguration generated-proguard-config.txt");
+ ExternalR8TestCompileResult result =
+ testForExternalR8(Backend.DEX)
+ .addProgramClasses(PrintConfigurationTestClass.class)
+ .addKeepRules(proguardConfig.trim())
+ .compile();
+ Path printConfigurationFile =
+ result.outputJar().getParent().resolve("generated-proguard-config.txt");
assertEquals(proguardConfig, FileUtils.readTextFile(printConfigurationFile, Charsets.UTF_8));
}
