diff --git a/src/main/java/com/android/tools/r8/ExtractR8Rules.java b/src/main/java/com/android/tools/r8/ExtractR8Rules.java
new file mode 100644
index 0000000..6d97afb
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ExtractR8Rules.java
@@ -0,0 +1,97 @@
+// Copyright (c) 2024, 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.keepanno.annotations.KeepForApi;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.EmbeddedRulesExtractor;
+import com.android.tools.r8.utils.ExceptionDiagnostic;
+import com.android.tools.r8.utils.ExceptionUtils;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.SemanticVersion;
+import com.android.tools.r8.utils.SemanticVersionUtils;
+import com.android.tools.r8.utils.StringUtils;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.function.Supplier;
+
+@KeepForApi
+public class ExtractR8Rules {
+
+  private static void run(
+      AndroidApp app,
+      StringConsumer consumer,
+      boolean includeOriginComments,
+      SemanticVersion fakeCompilerVersion,
+      Reporter reporter) {
+    Supplier<SemanticVersion> semanticVersionSupplier =
+        SemanticVersionUtils.compilerVersionSemanticVersionSupplier(
+            fakeCompilerVersion,
+            "Using an artificial version newer than any known version for selecting"
+                + " Proguard configurations embedded under META-INF/. This means that"
+                + " all rules with a '-upto-' qualifier will be excluded and all"
+                + " rules with a -from- qualifier will be included.",
+            reporter);
+    for (ProgramResourceProvider provider : app.getProgramResourceProviders()) {
+      DataResourceProvider dataResourceProvider = provider.getDataResourceProvider();
+      if (dataResourceProvider == null) {
+        return;
+      }
+      try {
+        EmbeddedRulesExtractor embeddedProguardConfigurationVisitor =
+            new EmbeddedRulesExtractor(reporter, semanticVersionSupplier);
+        dataResourceProvider.accept(embeddedProguardConfigurationVisitor);
+        embeddedProguardConfigurationVisitor.visitRelevantRules(
+            rules -> {
+              try {
+                if (includeOriginComments) {
+                  consumer.accept("# Rules extracted from:", reporter);
+                  consumer.accept(StringUtils.LINE_SEPARATOR, reporter);
+                  consumer.accept("# ", reporter);
+                  consumer.accept(rules.getOrigin().toString(), reporter);
+                  consumer.accept(StringUtils.LINE_SEPARATOR, reporter);
+                }
+                consumer.accept(rules.get(), reporter);
+                consumer.accept(StringUtils.LINE_SEPARATOR, reporter);
+              } catch (IOException e) {
+                throw new UncheckedIOException(e);
+              }
+            });
+      } catch (ResourceException e) {
+        reporter.error(new ExceptionDiagnostic(e));
+      }
+    }
+    consumer.finished(reporter);
+  }
+
+  /** Experimental API to extract embedded rules from libraries. */
+  public static void run(ExtractR8RulesCommand command) throws CompilationFailedException {
+    AndroidApp app = command.getInputApp();
+    StringConsumer rulesConsumer = command.getRulesConsumer();
+    boolean includeOriginComments = command.getIncludeOriginComments();
+    SemanticVersion fakeCompilerVersion = command.getFakeCompilerVersion();
+    InternalOptions options = command.getInternalOptions();
+    ExceptionUtils.withCompilationHandler(
+        options.reporter,
+        () -> {
+          run(app, rulesConsumer, includeOriginComments, fakeCompilerVersion, options.reporter);
+        });
+  }
+
+  public static void main(String[] args) throws CompilationFailedException {
+    ExtractR8RulesCommand.Builder builder = ExtractR8RulesCommand.parse(args);
+    ExtractR8RulesCommand command = builder.build();
+    if (command.isPrintHelp()) {
+      System.out.println(ExtractR8RulesCommand.USAGE_MESSAGE);
+      return;
+    }
+    if (command.isPrintVersion()) {
+      System.out.println("ExtractR8Rules " + Version.LABEL);
+      return;
+    }
+    run(command);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ExtractR8RulesCommand.java b/src/main/java/com/android/tools/r8/ExtractR8RulesCommand.java
new file mode 100644
index 0000000..3a55917
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ExtractR8RulesCommand.java
@@ -0,0 +1,184 @@
+// Copyright (c) 2024, 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.graph.DexItemFactory;
+import com.android.tools.r8.keepanno.annotations.KeepForApi;
+import com.android.tools.r8.origin.CommandLineOrigin;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.SemanticVersion;
+import com.android.tools.r8.utils.StringDiagnostic;
+import com.android.tools.r8.utils.StringUtils;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+@KeepForApi
+/** Experimental API to extract embedded rules from libraries. */
+public class ExtractR8RulesCommand extends BaseCommand {
+
+  private final StringConsumer rulesConsumer;
+  private final boolean includeOriginComments;
+  private final SemanticVersion fakeCompilerVersion;
+  private final DexItemFactory factory;
+  private final Reporter reporter;
+
+  @KeepForApi
+  public static class Builder extends BaseCommand.Builder<ExtractR8RulesCommand, Builder> {
+
+    private final DexItemFactory factory = new DexItemFactory();
+    private StringConsumer rulesConsumer = null;
+    private boolean includeOriginComments = false;
+    private SemanticVersion fakeCompilerVersion = null;
+
+    private Builder() {}
+
+    private Builder(DiagnosticsHandler diagnosticsHandler) {
+      super(diagnosticsHandler);
+    }
+
+    @Override
+    ExtractR8RulesCommand.Builder self() {
+      return this;
+    }
+
+    /** TBD */
+    public ExtractR8RulesCommand.Builder setRulesOutputPath(Path rulesOutputPath) {
+      rulesConsumer = new StringConsumer.FileConsumer(rulesOutputPath);
+      return self();
+    }
+
+    /** TBD */
+    public ExtractR8RulesCommand.Builder setRulesConsumer(StringConsumer rulesConsumer) {
+      this.rulesConsumer = rulesConsumer;
+      return self();
+    }
+
+    /** TBD */
+    public ExtractR8RulesCommand.Builder setIncludeOriginComments(boolean include) {
+      this.includeOriginComments = include;
+      return self();
+    }
+
+    /** TBD */
+    public Builder setFakeCompilerVersion(SemanticVersion version) {
+      fakeCompilerVersion = version;
+      return self();
+    }
+
+    @Override
+    protected ExtractR8RulesCommand makeCommand() {
+      // If printing versions ignore everything else.
+      if (isPrintHelp() || isPrintVersion()) {
+        return new ExtractR8RulesCommand(isPrintHelp(), isPrintVersion());
+      }
+
+      return new ExtractR8RulesCommand(
+          factory,
+          getAppBuilder().build(),
+          rulesConsumer,
+          includeOriginComments,
+          fakeCompilerVersion,
+          getReporter());
+    }
+  }
+
+  static final String USAGE_MESSAGE =
+      StringUtils.lines(
+          "Usage: TBD",
+          "  --rules-output <file>      # Output the extracted keep rules.",
+          "  --include-origin-comments  # Include comments with origin for extracted rules.",
+          "  --version                  # Print the version.",
+          "  --help                     # Print this message.");
+
+  public static ExtractR8RulesCommand.Builder builder() {
+    return new ExtractR8RulesCommand.Builder();
+  }
+
+  public static ExtractR8RulesCommand.Builder builder(DiagnosticsHandler diagnosticsHandler) {
+    return new ExtractR8RulesCommand.Builder(diagnosticsHandler);
+  }
+
+  public static ExtractR8RulesCommand.Builder parse(String[] args) {
+    ExtractR8RulesCommand.Builder builder = builder();
+    parse(args, builder);
+    return builder;
+  }
+
+  public StringConsumer getRulesConsumer() {
+    return rulesConsumer;
+  }
+
+  public boolean getIncludeOriginComments() {
+    return includeOriginComments;
+  }
+
+  public SemanticVersion getFakeCompilerVersion() {
+    return fakeCompilerVersion;
+  }
+
+  Reporter getReporter() {
+    return reporter;
+  }
+
+  private static void parse(String[] args, ExtractR8RulesCommand.Builder builder) {
+    for (int i = 0; i < args.length; i++) {
+      String arg = args[i].trim();
+      if (arg.length() == 0) {
+        continue;
+      } else if (arg.equals("--help")) {
+        builder.setPrintHelp(true);
+      } else if (arg.equals("--version")) {
+        builder.setPrintVersion(true);
+      } else if (arg.equals("--rules-output")) {
+        builder.setRulesOutputPath(Paths.get(args[++i]));
+      } else if (arg.equals("--include-origin-comments")) {
+        builder.setIncludeOriginComments(true);
+      } else {
+        if (arg.startsWith("--")) {
+          builder
+              .getReporter()
+              .fatalError(
+                  new StringDiagnostic("Unknown option: " + arg, CommandLineOrigin.INSTANCE));
+        }
+        builder.addProgramFiles(Paths.get(arg));
+      }
+    }
+  }
+
+  private ExtractR8RulesCommand(
+      DexItemFactory factory,
+      AndroidApp inputApp,
+      StringConsumer rulesConsumer,
+      boolean includeOriginComments,
+      SemanticVersion fakeCompilerVersion,
+      Reporter reporter) {
+    super(inputApp);
+    this.factory = factory;
+    this.rulesConsumer = rulesConsumer;
+    this.includeOriginComments = includeOriginComments;
+    this.fakeCompilerVersion = fakeCompilerVersion;
+    this.reporter = reporter;
+  }
+
+  private ExtractR8RulesCommand(boolean printHelp, boolean printVersion) {
+    super(printHelp, printVersion);
+    this.factory = new DexItemFactory();
+    this.rulesConsumer = null;
+    this.includeOriginComments = false;
+    this.fakeCompilerVersion = null;
+    this.reporter = new Reporter();
+  }
+
+  @Override
+  InternalOptions getInternalOptions() {
+    InternalOptions internal = new InternalOptions(factory, reporter);
+    internal.programConsumer = DexIndexedConsumer.emptyConsumer();
+    assert internal.retainCompileTimeAnnotations;
+    internal.retainCompileTimeAnnotations = false;
+    return internal;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/SwissArmyKnife.java b/src/main/java/com/android/tools/r8/SwissArmyKnife.java
index b9dd50f..c5608b7 100644
--- a/src/main/java/com/android/tools/r8/SwissArmyKnife.java
+++ b/src/main/java/com/android/tools/r8/SwissArmyKnife.java
@@ -74,6 +74,9 @@
       case "verify":
         CfVerifierTool.main(shift(args));
         break;
+      case "extractr8rules":
+        ExtractR8Rules.main(shift(args));
+        break;
       default:
         runDefault(args);
         break;
diff --git a/src/main/java/com/android/tools/r8/utils/EmbeddedRulesExtractor.java b/src/main/java/com/android/tools/r8/utils/EmbeddedRulesExtractor.java
index 7f68aa3..d9b972a 100644
--- a/src/main/java/com/android/tools/r8/utils/EmbeddedRulesExtractor.java
+++ b/src/main/java/com/android/tools/r8/utils/EmbeddedRulesExtractor.java
@@ -134,7 +134,15 @@
     }
   }
 
+  private List<ProguardConfigurationSource> getRelevantRules() {
+    return !r8Sources.isEmpty() ? r8Sources : proguardSources;
+  }
+
   public void parseRelevantRules(ProguardConfigurationParser parser) {
-    parse(!r8Sources.isEmpty() ? r8Sources : proguardSources, parser);
+    parse(getRelevantRules(), parser);
+  }
+
+  public void visitRelevantRules(Consumer<ProguardConfigurationSource> consumer) {
+    getRelevantRules().forEach(consumer);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/LibraryProvidedProguardRulesExtractR8RulesTest.java b/src/test/java/com/android/tools/r8/shaking/LibraryProvidedProguardRulesExtractR8RulesTest.java
new file mode 100644
index 0000000..36e68ca
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/LibraryProvidedProguardRulesExtractR8RulesTest.java
@@ -0,0 +1,230 @@
+// Copyright (c) 2024, 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.shaking;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.ExtractR8Rules;
+import com.android.tools.r8.ExtractR8RulesCommand;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.Pair;
+import com.android.tools.r8.utils.SemanticVersion;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.ZipUtils.ZipBuilder;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class LibraryProvidedProguardRulesExtractR8RulesTest
+    extends LibraryProvidedProguardRulesTestBase {
+
+  @Parameter(0)
+  public TestParameters parameters;
+
+  @Parameter(1)
+  public boolean includeOriginComments;
+
+  @Parameters(name = "{0}, includeOriginComments: {1}")
+  public static List<Object[]> data() {
+    return buildParameters(getTestParameters().withNoneRuntime().build(), BooleanUtils.values());
+  }
+
+  private static final String EXPECTED_A = StringUtils.lines("-keep class A1", "-keep class A2");
+
+  private static final String EXPECTED_B = StringUtils.lines("-keep class B1", "-keep class B2");
+
+  private static final String EXPECTED_C = StringUtils.lines("-keep class C1", "-keep class C2");
+
+  private static final String EXPECTED_D = StringUtils.lines("-keep class D1", "-keep class D2");
+
+  private static final String EXPECTED_E = StringUtils.lines("-keep class E1", "-keep class E2");
+
+  private static final String EXPECTED_X = StringUtils.lines("-keep class X1", "-keep class X2");
+
+  private List<Path> buildLibraries() throws Exception {
+    List<Path> result = new ArrayList<>();
+    List<Pair<String, String>> rules = new ArrayList<>();
+    rules.add(new Pair<>("META-INF/com.android.tools/r8/test1.pro", "-keep class A1"));
+    rules.add(new Pair<>("META-INF/com.android.tools/r8/test2.pro", "-keep class A2"));
+    rules.add(new Pair<>("META-INF/com.android.tools/r8-from-4.0.0/test1.pro", "-keep class B1"));
+    rules.add(new Pair<>("META-INF/com.android.tools/r8-from-4.0.0/test2.pro", "-keep class B2"));
+    rules.add(new Pair<>("META-INF/com.android.tools/r8-upto-8.1.0/test1.pro", "-keep class C1"));
+    rules.add(new Pair<>("META-INF/com.android.tools/r8-upto-8.1.0/test2.pro", "-keep class C2"));
+    rules.add(
+        new Pair<>(
+            "META-INF/com.android.tools/r8-from-5.0.0-upto-8.0.0/test1.pro", "-keep class D1"));
+    rules.add(
+        new Pair<>(
+            "META-INF/com.android.tools/r8-from-5.0.0-upto-8.0.0/test2.pro", "-keep class D2"));
+    rules.add(new Pair<>("META-INF/com.android.tools/r8-from-10.5.0/test1.pro", "-keep class E1"));
+    rules.add(new Pair<>("META-INF/com.android.tools/r8-from-10.5.0/test2.pro", "-keep class E2"));
+    rules.add(new Pair<>("META-INF/proguard/test1.pro", "-keep class X1"));
+    rules.add(new Pair<>("META-INF/proguard/test2.pro", "-keep class X2"));
+    Path folder = temp.newFolder().toPath();
+    for (int i = 0; i < rules.size(); i++) {
+      Path zipFile = folder.resolve("test" + i + ".jar");
+      ZipBuilder jarBuilder = ZipBuilder.builder(zipFile);
+      jarBuilder.addText(rules.get(i).getFirst(), rules.get(i).getSecond());
+      result.add(jarBuilder.build());
+    }
+    return result;
+  }
+
+  private String filterOriginCommentsFromExtractedRules(String extractedRules) {
+    List<String> newResult = new ArrayList<>();
+    List<String> lines = StringUtils.splitLines(extractedRules);
+    for (int i = 0; i < lines.size(); i++) {
+      String line = lines.get(i);
+      if (line.equals("# Rules extracted from:")) {
+        i++;
+        assertThat(lines.get(i), containsString("test"));
+        assertThat(lines.get(i), containsString(".jar"));
+      } else {
+        newResult.add(line);
+      }
+    }
+    return StringUtils.lines(newResult);
+  }
+
+  private void runTestRulesConsumer(SemanticVersion compilerVersion, String expected)
+      throws Exception {
+    List<Path> libraries = buildLibraries();
+    ExtractR8RulesCommand.Builder builder = ExtractR8RulesCommand.builder();
+    libraries.forEach(builder::addProgramFiles);
+    StringBuilder resultBuilder = new StringBuilder();
+    ExtractR8RulesCommand command =
+        builder
+            .setRulesConsumer((s, h) -> resultBuilder.append(s))
+            .setIncludeOriginComments(includeOriginComments)
+            .setFakeCompilerVersion(compilerVersion)
+            .build();
+    ExtractR8Rules.run(command);
+    String extractedRules = resultBuilder.toString();
+    if (includeOriginComments) {
+      extractedRules = filterOriginCommentsFromExtractedRules(extractedRules);
+    }
+    assertEquals(expected, extractedRules);
+  }
+
+  private void runTestRulesOutputPath(SemanticVersion compilerVersion, String expected)
+      throws Exception {
+    List<Path> libraries = buildLibraries();
+    ExtractR8RulesCommand.Builder builder = ExtractR8RulesCommand.builder();
+    libraries.forEach(builder::addProgramFiles);
+    Path rulesOutput = temp.newFile().toPath();
+    ExtractR8RulesCommand command =
+        builder
+            .setRulesOutputPath(rulesOutput)
+            .setIncludeOriginComments(includeOriginComments)
+            .setFakeCompilerVersion(compilerVersion)
+            .build();
+    ExtractR8Rules.run(command);
+    String extractedRules = FileUtils.readTextFile(rulesOutput, StandardCharsets.UTF_8);
+    if (includeOriginComments) {
+      extractedRules = filterOriginCommentsFromExtractedRules(extractedRules);
+    }
+    assertEquals(expected, extractedRules);
+  }
+
+  private void runTest(SemanticVersion compilerVersion, String expected) throws Exception {
+    runTestRulesConsumer(compilerVersion, expected);
+    runTestRulesOutputPath(compilerVersion, expected);
+  }
+
+  @Test
+  public void runTestVersion3() throws Exception {
+    runTest(
+        SemanticVersion.create(3, 0, 0),
+        StringUtils.lines(EXPECTED_A.trim(), EXPECTED_C.trim(), EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion4() throws Exception {
+    runTest(
+        SemanticVersion.create(4, 0, 0),
+        StringUtils.lines(
+            EXPECTED_A.trim(), EXPECTED_B.trim(), EXPECTED_C.trim(), EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion5() throws Exception {
+    runTest(
+        SemanticVersion.create(5, 0, 0),
+        StringUtils.lines(
+            EXPECTED_A.trim(),
+            EXPECTED_B.trim(),
+            EXPECTED_C.trim(),
+            EXPECTED_D.trim(),
+            EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion7_99_99() throws Exception {
+    runTest(
+        SemanticVersion.create(7, 99, 99),
+        StringUtils.lines(
+            EXPECTED_A.trim(),
+            EXPECTED_B.trim(),
+            EXPECTED_C.trim(),
+            EXPECTED_D.trim(),
+            EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion8() throws Exception {
+    runTest(
+        SemanticVersion.create(8, 0, 0),
+        StringUtils.lines(
+            EXPECTED_A.trim(), EXPECTED_B.trim(), EXPECTED_C.trim(), EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion8_0_99() throws Exception {
+    runTest(
+        SemanticVersion.create(8, 0, 99),
+        StringUtils.lines(
+            EXPECTED_A.trim(), EXPECTED_B.trim(), EXPECTED_C.trim(), EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion8_1() throws Exception {
+    runTest(
+        SemanticVersion.create(8, 1, 0),
+        StringUtils.lines(EXPECTED_A.trim(), EXPECTED_B.trim(), EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion8_2() throws Exception {
+    runTest(
+        SemanticVersion.create(8, 2, 0),
+        StringUtils.lines(EXPECTED_A.trim(), EXPECTED_B.trim(), EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion10() throws Exception {
+    runTest(
+        SemanticVersion.create(10, 0, 0),
+        StringUtils.lines(EXPECTED_A.trim(), EXPECTED_B.trim(), EXPECTED_X.trim()));
+  }
+
+  @Test
+  public void runTestVersion10_5() throws Exception {
+    runTest(
+        SemanticVersion.create(10, 5, 0),
+        StringUtils.lines(
+            EXPECTED_A.trim(), EXPECTED_B.trim(), EXPECTED_E.trim(), EXPECTED_X.trim()));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/LibraryProvidedProguardRulesR8SpecificTest.java b/src/test/java/com/android/tools/r8/shaking/LibraryProvidedProguardRulesR8SpecificTest.java
index ecc00c4..6ff21ff 100644
--- a/src/test/java/com/android/tools/r8/shaking/LibraryProvidedProguardRulesR8SpecificTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/LibraryProvidedProguardRulesR8SpecificTest.java
@@ -7,6 +7,8 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
 
+import com.android.tools.r8.ExtractR8Rules;
+import com.android.tools.r8.ExtractR8RulesCommand;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.Version;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -137,6 +139,20 @@
                 assertEquals(
                     expected,
                     stripCommentsAndInJars(configuration, providerType == ProviderType.INJARS)));
+
+    // Test the standalone rules extractor (test independent of providerType).
+    if (providerType == ProviderType.API) {
+      StringBuilder resultBuilder = new StringBuilder();
+      ExtractR8RulesCommand.Builder builder = ExtractR8RulesCommand.builder();
+      ExtractR8RulesCommand command =
+          builder
+              .addProgramFiles(library)
+              .setRulesConsumer((s, h) -> resultBuilder.append(s))
+              .setFakeCompilerVersion(compilerVersion)
+              .build();
+      ExtractR8Rules.run(command);
+      assertEquals(expected, resultBuilder.toString());
+    }
   }
 
   private static String stripCommentsAndInJars(String configuration, boolean expectOneInJar) {