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));
   }