diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApp.java b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
index a4f55c3..ed12177 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApp.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
@@ -60,6 +60,58 @@
   private final List<StringResource> mainDexListResources;
   private final List<String> mainDexClasses;
 
+  @Override
+  public String toString() {
+    StringBuilder builder = new StringBuilder();
+    try {
+      if (!programResourceProviders.isEmpty()) {
+        builder.append("  Program resources:").append(System.lineSeparator());
+        printProgramResourceProviders(builder, programResourceProviders);
+      }
+      if (!classpathResourceProviders.isEmpty()) {
+        builder.append("  Classpath resources:").append(System.lineSeparator());
+        printClassFileProviders(builder, classpathResourceProviders);
+      }
+      if (!libraryResourceProviders.isEmpty()) {
+        builder.append("  Library resources:").append(System.lineSeparator());
+        printClassFileProviders(builder, libraryResourceProviders);
+      }
+    } catch (ResourceException e) {
+      e.printStackTrace();
+    }
+    return builder.toString();
+  }
+
+  private static void printProgramResourceProviders(
+      StringBuilder builder, Collection<ProgramResourceProvider> providers)
+      throws ResourceException {
+    for (ProgramResourceProvider provider : providers) {
+      for (ProgramResource resource : provider.getProgramResources()) {
+        printProgramResource(builder, resource);
+      }
+    }
+  }
+
+  private static void printClassFileProviders(
+      StringBuilder builder, Collection<ClassFileResourceProvider> providers) {
+    for (ClassFileResourceProvider provider : providers) {
+      for (String descriptor : provider.getClassDescriptors()) {
+        ProgramResource resource = provider.getProgramResource(descriptor);
+        printProgramResource(builder, resource);
+      }
+    }
+  }
+
+  private static void printProgramResource(StringBuilder builder, ProgramResource resource) {
+    builder.append("    ").append(resource.getOrigin());
+    Set<String> descriptors = resource.getClassDescriptors();
+    if (descriptors != null && !descriptors.isEmpty()) {
+      builder.append(" contains ");
+      StringUtils.append(builder, descriptors);
+    }
+    builder.append(System.lineSeparator());
+  }
+
   // See factory methods and AndroidApp.Builder below.
   private AndroidApp(
       ImmutableList<ProgramResourceProvider> programResourceProviders,
diff --git a/src/test/java/com/android/tools/r8/D8TestBuilder.java b/src/test/java/com/android/tools/r8/D8TestBuilder.java
new file mode 100644
index 0000000..368e8e4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/D8TestBuilder.java
@@ -0,0 +1,51 @@
+// Copyright (c) 2018, 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.D8Command.Builder;
+import com.android.tools.r8.TestBase.Backend;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+
+public class D8TestBuilder extends TestCompilerBuilder<D8Command, Builder, D8TestBuilder> {
+
+  private final D8Command.Builder builder;
+
+  private D8TestBuilder(TestState state, D8Command.Builder builder) {
+    super(state, builder, Backend.DEX);
+    this.builder = builder;
+  }
+
+  public static D8TestBuilder create(TestState state) {
+    return new D8TestBuilder(state, D8Command.builder());
+  }
+
+  @Override
+  D8TestBuilder self() {
+    return this;
+  }
+
+  @Override
+  void internalCompile(Builder builder) throws CompilationFailedException {
+    D8.run(builder.build());
+  }
+
+  public D8TestBuilder addClasspathClasses(Class<?>... classes) {
+    return addClasspathClasses(Arrays.asList(classes));
+  }
+
+  public D8TestBuilder addClasspathClasses(Collection<Class<?>> classes) {
+    return addClasspathFiles(getFilesForClasses(classes));
+  }
+
+  public D8TestBuilder addClasspathFiles(Path... files) {
+    return addClasspathFiles(Arrays.asList(files));
+  }
+
+  public D8TestBuilder addClasspathFiles(Collection<Path> files) {
+    builder.addClasspathFiles(files);
+    return self();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/JvmTestBuilder.java b/src/test/java/com/android/tools/r8/JvmTestBuilder.java
new file mode 100644
index 0000000..484adee
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/JvmTestBuilder.java
@@ -0,0 +1,158 @@
+// Copyright (c) 2018, 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.ToolHelper.ProcessResult;
+import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.origin.PathOrigin;
+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.ListUtils;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+public class JvmTestBuilder extends TestBuilder<JvmTestBuilder> {
+
+  private static class ClassFileResource implements ProgramResource {
+
+    private final Path file;
+    private final String descriptor;
+    private final Origin origin;
+
+    ClassFileResource(Class<?> clazz) {
+      this(
+          ToolHelper.getClassFileForTestClass(clazz),
+          DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName()));
+    }
+
+    ClassFileResource(Path file, String descriptor) {
+      this.file = file;
+      this.descriptor = descriptor;
+      origin = new PathOrigin(file);
+    }
+
+    @Override
+    public Kind getKind() {
+      return Kind.CF;
+    }
+
+    @Override
+    public InputStream getByteStream() throws ResourceException {
+      try {
+        return Files.newInputStream(file);
+      } catch (IOException e) {
+        throw new ResourceException(getOrigin(), e);
+      }
+    }
+
+    @Override
+    public Set<String> getClassDescriptors() {
+      return Collections.singleton(descriptor);
+    }
+
+    @Override
+    public Origin getOrigin() {
+      return origin;
+    }
+  }
+
+  private static class ClassFileResourceProvider implements ProgramResourceProvider {
+
+    private final List<ProgramResource> resources;
+
+    public ClassFileResourceProvider(List<ProgramResource> resources) {
+      this.resources = resources;
+    }
+
+    @Override
+    public Collection<ProgramResource> getProgramResources() throws ResourceException {
+      return resources;
+    }
+
+    @Override
+    public DataResourceProvider getDataResourceProvider() {
+      return null;
+    }
+  }
+
+  // Ordered list of classpath entries.
+  private List<Path> classpath = new ArrayList<>();
+
+  private AndroidApp.Builder builder = AndroidApp.builder();
+
+  private JvmTestBuilder(TestState state) {
+    super(state);
+  }
+
+  public static JvmTestBuilder create(TestState state) {
+    return new JvmTestBuilder(state);
+  }
+
+  @Override
+  JvmTestBuilder self() {
+    return this;
+  }
+
+  @Override
+  public TestRunResult run(String mainClass) throws IOException {
+    ProcessResult result = ToolHelper.runJava(classpath, mainClass);
+    return new TestRunResult(builder.build(), result);
+  }
+
+  @Override
+  public JvmTestBuilder addLibraryFiles(Collection<Path> files) {
+    throw new Unimplemented("No support for changing the Java runtime library.");
+  }
+
+  @Override
+  public JvmTestBuilder 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.
+    List<ProgramResource> resources = ListUtils.map(classes, ClassFileResource::new);
+    AndroidApp build = AndroidApp.builder()
+        .addProgramResourceProvider(new ClassFileResourceProvider(resources)).build();
+    Path out;
+    try {
+      out = getState().getNewTempFolder().resolve("out.zip");
+      build.writeToZip(out, OutputMode.ClassFile);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+    classpath.add(out);
+    builder.addProgramFiles(out);
+    return self();
+  }
+
+  @Override
+  public JvmTestBuilder addProgramFiles(Collection<Path> files) {
+    throw new Unimplemented(
+        "No support for adding paths directly (we need to compute the descriptor)");
+  }
+
+  public JvmTestBuilder addClasspath(Path... paths) {
+    return addClasspath(Arrays.asList(paths));
+  }
+
+  public JvmTestBuilder addClasspath(List<Path> paths) {
+    for (Path path : paths) {
+      assert Files.isDirectory(path) || FileUtils.isArchive(path);
+      classpath.add(path);
+    }
+    return self();
+  }
+
+  public JvmTestBuilder addTestClasspath() {
+    return addClasspath(ToolHelper.getClassPathForTests());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/R8TestBuilder.java b/src/test/java/com/android/tools/r8/R8TestBuilder.java
new file mode 100644
index 0000000..50e659c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/R8TestBuilder.java
@@ -0,0 +1,84 @@
+// Copyright (c) 2018, 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.R8Command.Builder;
+import com.android.tools.r8.TestBase.Backend;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+public class R8TestBuilder extends TestCompilerBuilder<R8Command, Builder, R8TestBuilder> {
+
+  private final R8Command.Builder builder;
+
+  private R8TestBuilder(TestState state, Builder builder, Backend backend) {
+    super(state, builder, backend);
+    this.builder = builder;
+  }
+
+  public static R8TestBuilder create(TestState state, Backend backend) {
+    return new R8TestBuilder(state, R8Command.builder(), backend);
+  }
+
+  private boolean enableInliningAnnotations = false;
+
+  @Override
+  R8TestBuilder self() {
+    return this;
+  }
+
+  @Override
+  public void internalCompile(Builder builder) throws CompilationFailedException {
+    if (enableInliningAnnotations) {
+      ToolHelper.allowTestProguardOptions(builder);
+    }
+    R8.run(builder.build());
+  }
+
+  public R8TestBuilder addKeepRules(String... rules) {
+    return addKeepRules(Arrays.asList(rules));
+  }
+
+  public R8TestBuilder addKeepRules(Collection<String> rules) {
+    builder.addProguardConfiguration(new ArrayList<>(rules), Origin.unknown());
+    return self();
+  }
+
+  public R8TestBuilder addKeepAllClassesRule() {
+    addKeepRules("-keep class ** { *; }");
+    return self();
+  }
+
+  public R8TestBuilder addKeepClassRules(Class<?>... classes) {
+    for (Class<?> clazz : classes) {
+      addKeepRules("-keep class " + clazz.getTypeName());
+    }
+    return self();
+  }
+
+  public R8TestBuilder addKeepPackageRules(Package pkg) {
+    return addKeepRules("-keep class " + pkg.getName() + ".*");
+  }
+
+  public R8TestBuilder addKeepMainRule(Class<?> mainClass) {
+    return addKeepRules(
+        StringUtils.joinLines(
+            "-keep class " + mainClass.getTypeName() + " {",
+            "  public static void main(java.lang.String[]);",
+            "}"));
+  }
+
+  public R8TestBuilder enableInliningAnnotations() {
+    if (!enableInliningAnnotations) {
+      enableInliningAnnotations = true;
+      addKeepRules(
+          "-forceinline class * { @com.android.tools.r8.ForceInline *; }",
+          "-neverinline class * { @com.android.tools.r8.NeverInline *; }");
+    }
+    return self();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 94cc54b..efec188 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -59,6 +59,19 @@
 import org.objectweb.asm.ClassVisitor;
 
 public class TestBase {
+
+  public R8TestBuilder testForR8(Backend backend) {
+    return R8TestBuilder.create(new TestState(temp), backend);
+  }
+
+  public D8TestBuilder testForD8() {
+    return D8TestBuilder.create(new TestState(temp));
+  }
+
+  public JvmTestBuilder testForJvm() {
+    return JvmTestBuilder.create(new TestState(temp));
+  }
+
   public enum Backend {
     CF,
     DEX
diff --git a/src/test/java/com/android/tools/r8/TestBuilder.java b/src/test/java/com/android/tools/r8/TestBuilder.java
new file mode 100644
index 0000000..6d5a158
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/TestBuilder.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2018, 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.utils.FileUtils.CLASS_EXTENSION;
+
+import com.android.tools.r8.utils.ListUtils;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+public abstract class TestBuilder<T extends TestBuilder<T>> {
+
+  private final TestState state;
+
+  public TestBuilder(TestState state) {
+    this.state = state;
+  }
+
+  public TestState getState() {
+    return state;
+  }
+
+  abstract T self();
+
+  public abstract TestRunResult run(String mainClass)
+      throws IOException, CompilationFailedException;
+
+  public TestRunResult run(Class mainClass) throws IOException, CompilationFailedException {
+    return run(mainClass.getTypeName());
+  }
+
+  public abstract T addProgramFiles(Collection<Path> files);
+
+  public T addProgramClasses(Class<?>... classes) {
+    return addProgramClasses(Arrays.asList(classes));
+  }
+
+  public T addProgramClasses(Collection<Class<?>> classes) {
+    return addProgramFiles(getFilesForClasses(classes));
+  }
+
+  public T addProgramFiles(Path... files) {
+    return addProgramFiles(Arrays.asList(files));
+  }
+
+  public T addProgramClassesAndInnerClasses(Class<?>... classes) throws IOException {
+    return addProgramClassesAndInnerClasses(Arrays.asList(classes));
+  }
+
+  public T addProgramClassesAndInnerClasses(Collection<Class<?>> classes) throws IOException {
+    return addProgramFiles(getFilesForClassesAndInnerClasses(classes));
+  }
+
+  public abstract T addLibraryFiles(Collection<Path> files);
+
+  public T addLibraryClasses(Class<?>... classes) {
+    return addLibraryClasses(Arrays.asList(classes));
+  }
+
+  public T addLibraryClasses(Collection<Class<?>> classes) {
+    return addLibraryFiles(getFilesForClasses(classes));
+  }
+
+  public T addLibraryFiles(Path... files) {
+    return addLibraryFiles(Arrays.asList(files));
+  }
+
+  static Collection<Path> getFilesForClasses(Collection<Class<?>> classes) {
+    return ListUtils.map(classes, ToolHelper::getClassFileForTestClass);
+  }
+
+  static Collection<Path> getFilesForClassesAndInnerClasses(Collection<Class<?>> classes)
+      throws IOException {
+    Set<Path> paths = new HashSet<>();
+    for (Class clazz : classes) {
+      Path path = ToolHelper.getClassFileForTestClass(clazz);
+      String prefix = path.toString().replace(CLASS_EXTENSION, "$");
+      paths.addAll(
+          ToolHelper.getClassFilesForTestDirectory(
+              path.getParent(), p -> p.equals(path) || p.toString().startsWith(prefix)));
+    }
+    return paths;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
new file mode 100644
index 0000000..9996dde
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2018, 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.errors.Unreachable;
+import com.android.tools.r8.utils.AndroidApp;
+import java.io.IOException;
+import java.nio.file.Path;
+
+public class TestCompileResult {
+  private final TestState state;
+  private final Backend backend;
+  private final AndroidApp app;
+
+  public TestCompileResult(TestState state, Backend backend, AndroidApp app) {
+    this.state = state;
+    this.backend = backend;
+    this.app = app;
+  }
+
+  public TestRunResult run(String mainClass) throws IOException {
+    switch (backend) {
+      case DEX:
+        return runArt(mainClass);
+      case CF:
+        return runJava(mainClass);
+      default:
+        throw new Unreachable();
+    }
+  }
+
+  private TestRunResult runJava(String mainClass) throws IOException {
+    Path out = state.getNewTempFolder().resolve("out.zip");
+    app.writeToZip(out, OutputMode.ClassFile);
+    ProcessResult result = ToolHelper.runJava(out, mainClass);
+    return new TestRunResult(app, result);
+  }
+
+  private TestRunResult 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 new TestRunResult(app, result);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/TestCompilerBuilder.java b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
new file mode 100644
index 0000000..c6af2c7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/TestCompilerBuilder.java
@@ -0,0 +1,95 @@
+// Copyright (c) 2018, 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.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.AndroidAppConsumers;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+
+public abstract class TestCompilerBuilder<
+        C extends BaseCompilerCommand,
+        B extends BaseCompilerCommand.Builder<C, B>,
+        T extends TestCompilerBuilder<C, B, T>>
+    extends TestBuilder<T> {
+
+  private final B builder;
+  private final Backend backend;
+
+  // Default initialized setup. Can be overwritten if needed.
+  private Path defaultLibrary;
+  private ProgramConsumer programConsumer;
+  private AndroidApiLevel defaultMinApiLevel = ToolHelper.getMinApiLevelForDexVm();
+
+  TestCompilerBuilder(TestState state, B builder, Backend backend) {
+    super(state);
+    this.builder = builder;
+    this.backend = backend;
+    defaultLibrary = TestBase.runtimeJar(backend);
+    programConsumer = TestBase.emptyConsumer(backend);
+  }
+
+  abstract T self();
+
+  abstract void internalCompile(B builder) throws CompilationFailedException;
+
+  public TestCompileResult compile() throws CompilationFailedException {
+    AndroidAppConsumers sink = new AndroidAppConsumers();
+    builder.setProgramConsumer(sink.wrapProgramConsumer(programConsumer));
+    if (defaultLibrary != null) {
+      builder.addLibraryFiles(defaultLibrary);
+    }
+    if (backend == Backend.DEX && defaultMinApiLevel != null) {
+      builder.setMinApiLevel(defaultMinApiLevel.getLevel());
+    }
+    internalCompile(builder);
+    return new TestCompileResult(getState(), backend, sink.build());
+  }
+
+  @Override
+  public TestRunResult run(String mainClass) throws IOException, CompilationFailedException {
+    return compile().run(mainClass);
+  }
+
+  public T setMode(CompilationMode mode) {
+    builder.setMode(mode);
+    return self();
+  }
+
+  public T debug() {
+    return setMode(CompilationMode.DEBUG);
+  }
+
+  public T release() {
+    return setMode(CompilationMode.RELEASE);
+  }
+
+  public T setMinApi(AndroidApiLevel minApiLevel) {
+    // Should we ignore min-api calls when backend == CF?
+    this.defaultMinApiLevel = null;
+    builder.setMinApiLevel(minApiLevel.getLevel());
+    return self();
+  }
+
+  public T setProgramConsumer(ProgramConsumer programConsumer) {
+    assert programConsumer != null;
+    this.programConsumer = programConsumer;
+    return self();
+  }
+
+  @Override
+  public T addProgramFiles(Collection<Path> files) {
+    builder.addProgramFiles(files);
+    return self();
+  }
+
+  @Override
+  public T addLibraryFiles(Collection<Path> files) {
+    defaultLibrary = null;
+    builder.addLibraryFiles(files);
+    return self();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/TestRunResult.java b/src/test/java/com/android/tools/r8/TestRunResult.java
new file mode 100644
index 0000000..462ca1f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/TestRunResult.java
@@ -0,0 +1,68 @@
+// Copyright (c) 2018, 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.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+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.util.concurrent.ExecutionException;
+
+public class TestRunResult {
+  private final AndroidApp app;
+  private final ProcessResult result;
+
+  public TestRunResult(AndroidApp app, ProcessResult result) {
+    this.app = app;
+    this.result = result;
+  }
+
+  public TestRunResult assertSuccess() {
+    assertEquals(errorMessage("Expected run to succeed."), 0, result.exitCode);
+    return this;
+  }
+
+  public TestRunResult assertFailure() {
+    assertNotEquals(errorMessage("Expected run to fail."), 0, result.exitCode);
+    return this;
+  }
+
+  public void assertSuccessWithOutput(String expected) {
+    assertSuccess();
+    assertEquals(errorMessage("Run std output incorrect."), expected, result.stdout);
+  }
+
+  public CodeInspector inspector() throws IOException, ExecutionException {
+    // Inspection post run implies success. If inspection of an invalid program is needed it should
+    // be done on the compilation result or on the input.
+    assertSuccess();
+    assertNotNull(app);
+    return new CodeInspector(app);
+  }
+
+  private String errorMessage(String message) {
+    StringBuilder builder = new StringBuilder(message).append('\n');
+    printInfo(builder);
+    return builder.toString();
+  }
+
+  private void printInfo(StringBuilder builder) {
+    builder.append("APPLICATION: ");
+    printApplication(builder);
+    builder.append('\n');
+    printProcessResult(builder);
+  }
+
+  private void printApplication(StringBuilder builder) {
+    builder.append(app == null ? "<default>" : app.toString());
+  }
+
+  private void printProcessResult(StringBuilder builder) {
+    builder.append("COMMAND: ").append(result.command).append('\n').append(result);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/TestState.java b/src/test/java/com/android/tools/r8/TestState.java
new file mode 100644
index 0000000..d516c7c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/TestState.java
@@ -0,0 +1,21 @@
+// Copyright (c) 2018, 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 java.io.IOException;
+import java.nio.file.Path;
+import org.junit.rules.TemporaryFolder;
+
+public class TestState {
+
+  private final TemporaryFolder temp;
+
+  public TestState(TemporaryFolder temp) {
+    this.temp = temp;
+  }
+
+  public Path getNewTempFolder() throws IOException {
+    return temp.newFolder().toPath();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 515d191..8ae0dad 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -1531,11 +1531,17 @@
     public final int exitCode;
     public final String stdout;
     public final String stderr;
+    public final String command;
 
-    ProcessResult(int exitCode, String stdout, String stderr) {
+    ProcessResult(int exitCode, String stdout, String stderr, String command) {
       this.exitCode = exitCode;
       this.stdout = stdout;
       this.stderr = stderr;
+      this.command = command;
+    }
+
+    ProcessResult(int exitCode, String stdout, String stderr) {
+      this(exitCode, stdout, stderr, null);
     }
 
     @Override
@@ -1574,7 +1580,8 @@
   }
 
   public static ProcessResult runProcess(ProcessBuilder builder) throws IOException {
-    System.out.println(String.join(" ", builder.command()));
+    String command = String.join(" ", builder.command());
+    System.out.println(command);
     Process p = builder.start();
     // Drain stdout and stderr so that the process does not block. Read stdout and stderr
     // in parallel to make sure that neither buffer can get filled up which will cause the
@@ -1592,7 +1599,8 @@
     } catch (InterruptedException e) {
       throw new RuntimeException("Execution interrupted", e);
     }
-    return new ProcessResult(p.exitValue(), stdoutReader.getResult(), stderrReader.getResult());
+    return new ProcessResult(
+        p.exitValue(), stdoutReader.getResult(), stderrReader.getResult(), command);
   }
 
   public static R8Command.Builder addProguardConfigurationConsumer(
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/IndirectSuperInterfaceTest.java b/src/test/java/com/android/tools/r8/memberrebinding/IndirectSuperInterfaceTest.java
index 9552a61..977b925 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/IndirectSuperInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/IndirectSuperInterfaceTest.java
@@ -3,17 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.memberrebinding;
 
-import static org.junit.Assert.assertEquals;
-
 import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8;
-import com.android.tools.r8.R8Command;
-import com.android.tools.r8.R8Command.Builder;
 import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.utils.AndroidAppConsumers;
+import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
 import org.junit.Test;
@@ -149,38 +141,23 @@
 
   @Test
   public void test() throws Exception {
-    String expected =
-        String.join(
-            System.lineSeparator(),
-            "A::method -> InterfaceA::method",
-            "B::method -> InterfaceB::method",
-            "C::method -> InterfaceC::method",
-            "D::method -> InterfaceD::method");
-    assertEquals(expected, runOnJava(TestClass.class));
+    String expected = StringUtils.joinLines(
+        "A::method -> InterfaceA::method",
+        "B::method -> InterfaceB::method",
+        "C::method -> InterfaceC::method",
+        "D::method -> InterfaceD::method");
 
-    AndroidAppConsumers sink = new AndroidAppConsumers();
-    Builder builder = R8Command.builder();
-    for (Class<?> clazz : CLASSES) {
-      builder.addClassProgramData(ToolHelper.getClassAsBytes(clazz), Origin.unknown());
-    }
-    builder
-        .setProgramConsumer(sink.wrapProgramConsumer(emptyConsumer(backend)))
-        .addLibraryFiles(runtimeJar(backend))
-        .addProguardConfiguration(
-            ImmutableList.of(
-                // Keep all classes to prevent changes to the class hierarchy (e.g., due to
-                // vertical class merging).
-                "-keep class " + InterfaceA.class.getPackage().getName() + ".*",
-                keepMainProguardConfigurationWithInliningAnnotation(TestClass.class)),
-            Origin.unknown());
-    ToolHelper.allowTestProguardOptions(builder);
-    if (backend == Backend.DEX) {
-      builder.setMinApiLevel(ToolHelper.getMinApiLevelForDexVm().getLevel());
-    }
-    R8.run(builder.build());
+    testForJvm()
+        .addTestClasspath()
+        .run(TestClass.class)
+        .assertSuccessWithOutput(expected);
 
-    ProcessResult result = runOnVMRaw(sink.build(), TestClass.class, backend);
-    assertEquals(result.toString(), 0, result.exitCode);
-    assertEquals(expected, result.stdout);
+    testForR8(backend)
+        .addProgramClasses(CLASSES)
+        .addKeepPackageRules(TestClass.class.getPackage())
+        .addKeepMainRule(TestClass.class)
+        .enableInliningAnnotations()
+        .run(TestClass.class)
+        .assertSuccessWithOutput(expected);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/KeepAttributesTest.java b/src/test/java/com/android/tools/r8/shaking/KeepAttributesTest.java
index 96ce54a..6992f97 100644
--- a/src/test/java/com/android/tools/r8/shaking/KeepAttributesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/KeepAttributesTest.java
@@ -9,15 +9,8 @@
 
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.CompilationMode;
-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.origin.Origin;
 import com.android.tools.r8.shaking.forceproguardcompatibility.keepattributes.TestKeepAttributes;
-import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.AndroidAppConsumers;
-import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableList;
 import java.io.IOException;
@@ -70,7 +63,6 @@
   public void keepLineNumberTable()
       throws CompilationFailedException, IOException, ExecutionException {
     List<String> keepRules = ImmutableList.of(
-        "-keep class ** { *; }",
         "-keepattributes " + ProguardKeepAttributes.LINE_NUMBER_TABLE
     );
     MethodSubject mainMethod = compileRunAndGetMain(keepRules, CompilationMode.RELEASE);
@@ -82,7 +74,6 @@
   public void keepLineNumberTableAndLocalVariableTable()
       throws CompilationFailedException, IOException, ExecutionException {
     List<String> keepRules = ImmutableList.of(
-        "-keep class ** { *; }",
         "-keepattributes "
             + ProguardKeepAttributes.LINE_NUMBER_TABLE
             + ", "
@@ -97,7 +88,6 @@
   @Test
   public void keepLocalVariableTable() throws IOException, ExecutionException {
     List<String> keepRules = ImmutableList.of(
-        "-keep class ** { *; }",
         "-keepattributes " + ProguardKeepAttributes.LOCAL_VARIABLE_TABLE
     );
     // Compiling with a keep rule for locals but no line results in an error in R8.
@@ -113,21 +103,14 @@
 
   private MethodSubject compileRunAndGetMain(List<String> keepRules, CompilationMode mode)
       throws CompilationFailedException, IOException, ExecutionException {
-    AndroidAppConsumers sink = new AndroidAppConsumers();
-    R8.run(
-        R8Command.builder()
-            .setMode(mode)
-            .addProgramFiles(
-                ToolHelper.getClassFilesForTestDirectory(
-                    ToolHelper.getClassFileForTestClass(CLASS).getParent()))
-            .addLibraryFiles(runtimeJar(backend))
-            .addProguardConfiguration(keepRules, Origin.unknown())
-            .setProgramConsumer(sink.wrapProgramConsumer(emptyConsumer(backend)))
-            .build());
-    AndroidApp app = sink.build();
-    CodeInspector codeInspector = new CodeInspector(app);
-    runOnVM(app, CLASS.getTypeName(), backend);
-    return codeInspector.clazz(CLASS).mainMethod();
+    return testForR8(backend)
+        .setMode(mode)
+        .addProgramClassesAndInnerClasses(CLASS)
+        .addKeepAllClassesRule()
+        .addKeepRules(keepRules)
+        .run(CLASS)
+        .inspector()
+        .clazz(CLASS)
+        .mainMethod();
   }
-
 }