diff --git a/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelInterfaceTest.java b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelInterfaceTest.java
new file mode 100644
index 0000000..e56d36e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelInterfaceTest.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2021, 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.apimodeling;
+
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.setMockApiLevelForMethod;
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.verifyThat;
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.lang.reflect.Method;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelingNoInliningOfHigherApiLevelInterfaceTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+  }
+
+  public ApiModelingNoInliningOfHigherApiLevelInterfaceTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Method apiMethod = Api.class.getDeclaredMethod("apiLevel22");
+    Method apiCaller = ApiCaller.class.getDeclaredMethod("callInterfaceMethod", Api.class);
+    Method apiCallerCaller = A.class.getDeclaredMethod("noApiCall");
+    R8TestRunResult runResult =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(Main.class, A.class, ApiCaller.class)
+            .addLibraryClasses(Api.class)
+            .addDefaultRuntimeLibrary(parameters)
+            .setMinApi(parameters.getApiLevel())
+            .addKeepMainRule(Main.class)
+            .enableInliningAnnotations()
+            .enableNoHorizontalClassMergingAnnotations()
+            .apply(setMockApiLevelForMethod(apiMethod, AndroidApiLevel.L_MR1))
+            .run(parameters.getRuntime(), Main.class)
+            .assertSuccessWithOutputLines("A::noApiCall", "ApiCaller::callInterfaceMethod");
+    if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L_MR1)) {
+      runResult.inspect(
+          verifyThat(parameters, apiCaller)
+              .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1));
+    } else {
+      // TODO(b/188388130): Should only inline on minApi >= 22.
+      assertThrows(
+          AssertionError.class,
+          () ->
+              runResult.inspect(
+                  verifyThat(parameters, apiCaller)
+                      .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1)));
+    }
+  }
+
+  public interface Api {
+
+    void apiLevel22();
+  }
+
+  @NoHorizontalClassMerging
+  public static class ApiCaller {
+
+    public static void callInterfaceMethod(Api api) {
+      System.out.println("ApiCaller::callInterfaceMethod");
+      if (api != null) {
+        api.apiLevel22();
+      }
+    }
+  }
+
+  @NoHorizontalClassMerging
+  public static class A {
+
+    @NeverInline
+    public static void noApiCall() {
+      System.out.println("A::noApiCall");
+      ApiCaller.callInterfaceMethod(null);
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      A.noApiCall();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelIntoLowerDirectTest.java b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelIntoLowerDirectTest.java
new file mode 100644
index 0000000..174dcf7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelIntoLowerDirectTest.java
@@ -0,0 +1,78 @@
+// Copyright (c) 2021, 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.apimodeling;
+
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.setMockApiLevelForMethod;
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.verifyThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.lang.reflect.Method;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelingNoInliningOfHigherApiLevelIntoLowerDirectTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+  }
+
+  public ApiModelingNoInliningOfHigherApiLevelIntoLowerDirectTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test()
+  public void testR8() throws Exception {
+    Method apiLevel21 = A.class.getDeclaredMethod("apiLevel21");
+    Method apiLevel22 = B.class.getDeclaredMethod("apiLevel22");
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .enableNoHorizontalClassMergingAnnotations()
+        .apply(setMockApiLevelForMethod(apiLevel21, AndroidApiLevel.L))
+        .apply(setMockApiLevelForMethod(apiLevel22, AndroidApiLevel.L_MR1))
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("A::apiLevel21", "B::apiLevel22")
+        .inspect(verifyThat(parameters, apiLevel22).inlinedInto(apiLevel21));
+  }
+
+  // This tests that program classes where we directly mock the methods to have an api level will
+  // be inlined.
+  @NoHorizontalClassMerging
+  public static class B {
+    public static void apiLevel22() {
+      System.out.println("B::apiLevel22");
+    }
+  }
+
+  @NoHorizontalClassMerging
+  public static class A {
+
+    @NeverInline
+    public static void apiLevel21() {
+      System.out.println("A::apiLevel21");
+      B.apiLevel22();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      A.apiLevel21();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelStaticTest.java b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelStaticTest.java
new file mode 100644
index 0000000..7130631
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelStaticTest.java
@@ -0,0 +1,105 @@
+// Copyright (c) 2021, 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.apimodeling;
+
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.setMockApiLevelForMethod;
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.verifyThat;
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.lang.reflect.Method;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelingNoInliningOfHigherApiLevelStaticTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+  }
+
+  public ApiModelingNoInliningOfHigherApiLevelStaticTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Method apiMethod = Api.class.getDeclaredMethod("apiLevel22");
+    Method apiCaller = ApiCaller.class.getDeclaredMethod("callStaticMethod");
+    Method apiCallerCaller = A.class.getDeclaredMethod("noApiCall");
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class, A.class, ApiCaller.class)
+        .addLibraryClasses(Api.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .enableNoHorizontalClassMergingAnnotations()
+        .apply(setMockApiLevelForMethod(apiMethod, AndroidApiLevel.L_MR1))
+        .compile()
+        .inspect(
+            inspector -> {
+              if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L_MR1)) {
+                verifyThat(parameters, apiCaller)
+                    .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1)
+                    .accept(inspector);
+              } else {
+                // TODO(b/188388130): Should only inline on minApi >= 22.
+                assertThrows(
+                    AssertionError.class,
+                    () ->
+                        verifyThat(parameters, apiCaller)
+                            .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1)
+                            .accept(inspector));
+              }
+            })
+        .addRunClasspathClasses(Api.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(
+            "A::noApiCall", "ApiCaller::callStaticMethod", "Api::apiLevel22");
+  }
+
+  public static class Api {
+
+    public static void apiLevel22() {
+      System.out.println("Api::apiLevel22");
+    }
+  }
+
+  @NoHorizontalClassMerging
+  public static class ApiCaller {
+    public static void callStaticMethod() {
+      System.out.println("ApiCaller::callStaticMethod");
+      Api.apiLevel22();
+    }
+  }
+
+  @NoHorizontalClassMerging
+  public static class A {
+
+    @NeverInline
+    public static void noApiCall() {
+      System.out.println("A::noApiCall");
+      ApiCaller.callStaticMethod();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      A.noApiCall();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelSuperTest.java b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelSuperTest.java
new file mode 100644
index 0000000..7f96dbc9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelSuperTest.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2021, 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.apimodeling;
+
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.setMockApiLevelForMethod;
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.verifyThat;
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.lang.reflect.Method;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelingNoInliningOfHigherApiLevelSuperTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+  }
+
+  public ApiModelingNoInliningOfHigherApiLevelSuperTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Method apiMethod = Api.class.getDeclaredMethod("apiLevel22");
+    Method apiCaller = ApiCaller.class.getDeclaredMethod("apiLevel22");
+    Method apiCallerCaller = A.class.getDeclaredMethod("noApiCall");
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .enableNoHorizontalClassMergingAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .apply(setMockApiLevelForMethod(apiMethod, AndroidApiLevel.L_MR1))
+        .compile()
+        .inspect(
+            inspector -> {
+              if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L_MR1)) {
+                verifyThat(parameters, apiCaller)
+                    .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1)
+                    .accept(inspector);
+              } else {
+                // TODO(b/188388130): Should only inline on minApi >= 22.
+                assertThrows(
+                    AssertionError.class,
+                    () ->
+                        verifyThat(parameters, apiCaller)
+                            .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1)
+                            .accept(inspector));
+              }
+            })
+        .addRunClasspathClasses(Api.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines("A::noApiCall", "ApiCaller::apiLevel22", "Api::apiLevel22");
+  }
+
+  @NoHorizontalClassMerging
+  public static class Api {
+
+    void apiLevel22() {
+      System.out.println("Api::apiLevel22");
+    }
+  }
+
+  @NeverClassInline
+  public static class ApiCaller extends Api {
+
+    @Override
+    void apiLevel22() {
+      System.out.println("ApiCaller::apiLevel22");
+      super.apiLevel22();
+    }
+  }
+
+  @NoHorizontalClassMerging
+  public static class A {
+
+    @NeverInline
+    public static void noApiCall() {
+      System.out.println("A::noApiCall");
+      new ApiCaller().apiLevel22();
+    }
+  }
+
+  @NoHorizontalClassMerging
+  public static class Main {
+
+    public static void main(String[] args) {
+      A.noApiCall();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelVirtualTest.java b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelVirtualTest.java
new file mode 100644
index 0000000..fdf184e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingNoInliningOfHigherApiLevelVirtualTest.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2021, 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.apimodeling;
+
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.setMockApiLevelForMethod;
+import static com.android.tools.r8.apimodeling.ApiModelingTestHelper.verifyThat;
+import static org.junit.Assert.assertThrows;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoHorizontalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.lang.reflect.Method;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ApiModelingNoInliningOfHigherApiLevelVirtualTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
+  }
+
+  public ApiModelingNoInliningOfHigherApiLevelVirtualTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Method apiMethod = Api.class.getDeclaredMethod("apiLevel22");
+    Method apiCaller = ApiCaller.class.getDeclaredMethod("callVirtualMethod");
+    Method apiCallerCaller = A.class.getDeclaredMethod("noApiCall");
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class, A.class, ApiCaller.class)
+        .addLibraryClasses(Api.class)
+        .addDefaultRuntimeLibrary(parameters)
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableInliningAnnotations()
+        .enableNoHorizontalClassMergingAnnotations()
+        .enableNeverClassInliningAnnotations()
+        .apply(setMockApiLevelForMethod(apiMethod, AndroidApiLevel.L_MR1))
+        .compile()
+        .inspect(
+            inspector -> {
+              if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L_MR1)) {
+                verifyThat(parameters, apiCaller)
+                    .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1)
+                    .accept(inspector);
+              } else {
+                // TODO(b/188388130): Should only inline on minApi >= 22.
+                assertThrows(
+                    AssertionError.class,
+                    () ->
+                        verifyThat(parameters, apiCaller)
+                            .inlinedIntoFromApiLevel(apiCallerCaller, AndroidApiLevel.L_MR1)
+                            .accept(inspector));
+              }
+            })
+        .addRunClasspathClasses(Api.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(
+            "A::noApiCall", "ApiCaller::callVirtualMethod", "Api::apiLevel22");
+  }
+
+  public static class Api {
+
+    public void apiLevel22() {
+      System.out.println("Api::apiLevel22");
+    }
+  }
+
+  @NoHorizontalClassMerging
+  @NeverClassInline
+  public static class ApiCaller {
+    public void callVirtualMethod() {
+      System.out.println("ApiCaller::callVirtualMethod");
+      new Api().apiLevel22();
+    }
+  }
+
+  @NoHorizontalClassMerging
+  public static class A {
+
+    @NeverInline
+    public static void noApiCall() {
+      System.out.println("A::noApiCall");
+      new ApiCaller().callVirtualMethod();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      A.noApiCall();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningTestHelper.java b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingTestHelper.java
similarity index 82%
rename from src/test/java/com/android/tools/r8/apioutlining/ApiOutliningTestHelper.java
rename to src/test/java/com/android/tools/r8/apimodeling/ApiModelingTestHelper.java
index f10a6e9..d22c4bb 100644
--- a/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningTestHelper.java
+++ b/src/test/java/com/android/tools/r8/apimodeling/ApiModelingTestHelper.java
@@ -2,7 +2,7 @@
 // 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.apioutlining;
+package com.android.tools.r8.apimodeling;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.not;
@@ -19,7 +19,7 @@
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import java.lang.reflect.Method;
 
-public abstract class ApiOutliningTestHelper {
+public abstract class ApiModelingTestHelper {
 
   static <T extends TestCompilerBuilder<?, ?, ?, ?, ?>>
       ThrowableConsumer<T> setMockApiLevelForMethod(Method method, AndroidApiLevel apiLevel) {
@@ -31,17 +31,16 @@
     };
   }
 
-  static ApiOutliningMethodVerificationHelper verifyThat(TestParameters parameters, Method method) {
-    return new ApiOutliningMethodVerificationHelper(parameters, method);
+  static ApiModelingMethodVerificationHelper verifyThat(TestParameters parameters, Method method) {
+    return new ApiModelingMethodVerificationHelper(parameters, method);
   }
 
-  public static class ApiOutliningMethodVerificationHelper {
+  public static class ApiModelingMethodVerificationHelper {
 
     private final Method methodOfInterest;
     private final TestParameters parameters;
 
-    public ApiOutliningMethodVerificationHelper(
-        TestParameters parameters, Method methodOfInterest) {
+    public ApiModelingMethodVerificationHelper(TestParameters parameters, Method methodOfInterest) {
       this.methodOfInterest = methodOfInterest;
       this.parameters = parameters;
     }
@@ -63,7 +62,7 @@
       };
     }
 
-    private ThrowingConsumer<CodeInspector, Exception> inlinedInto(Method method) {
+    public ThrowingConsumer<CodeInspector, Exception> inlinedInto(Method method) {
       return inspector -> {
         MethodSubject candidate = inspector.method(methodOfInterest);
         if (!candidate.isPresent()) {
diff --git a/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningNoInliningOfHigherApiLevelIntoLowerTest.java b/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningNoInliningOfHigherApiLevelIntoLowerTest.java
deleted file mode 100644
index 7620ae4..0000000
--- a/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningNoInliningOfHigherApiLevelIntoLowerTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2021, 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.apioutlining;
-
-import static com.android.tools.r8.apioutlining.ApiOutliningTestHelper.setMockApiLevelForMethod;
-import static com.android.tools.r8.apioutlining.ApiOutliningTestHelper.verifyThat;
-import static org.junit.Assert.assertThrows;
-
-import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import java.lang.reflect.Method;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-@RunWith(Parameterized.class)
-public class ApiOutliningNoInliningOfHigherApiLevelIntoLowerTest extends TestBase {
-
-  private final TestParameters parameters;
-
-  @Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
-  }
-
-  public ApiOutliningNoInliningOfHigherApiLevelIntoLowerTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test()
-  public void testR8() throws Exception {
-    Method apiLevel21 = A.class.getDeclaredMethod("apiLevel21");
-    Method apiLevel22 = B.class.getDeclaredMethod("apiLevel22");
-    R8TestRunResult runResult =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(getClass())
-            .setMinApi(parameters.getApiLevel())
-            .addKeepMainRule(Main.class)
-            .enableInliningAnnotations()
-            .apply(setMockApiLevelForMethod(apiLevel21, AndroidApiLevel.L))
-            .apply(setMockApiLevelForMethod(apiLevel22, AndroidApiLevel.L_MR1))
-            .run(parameters.getRuntime(), Main.class)
-            .assertSuccessWithOutputLines("A::apiLevel21", "B::apiLevel22");
-    if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L_MR1)) {
-      runResult.inspect(
-          verifyThat(parameters, apiLevel22)
-              .inlinedIntoFromApiLevel(apiLevel21, AndroidApiLevel.L_MR1));
-    } else {
-      // TODO(b/188388130): Should only inline on minApi >= 22.
-      assertThrows(
-          AssertionError.class,
-          () ->
-              runResult.inspect(
-                  verifyThat(parameters, apiLevel22)
-                      .inlinedIntoFromApiLevel(apiLevel21, AndroidApiLevel.L_MR1)));
-    }
-  }
-
-  public static class B {
-    public static void apiLevel22() {
-      System.out.println("B::apiLevel22");
-    }
-  }
-
-  public static class A {
-
-    @NeverInline
-    public static void apiLevel21() {
-      System.out.println("A::apiLevel21");
-      B.apiLevel22();
-    }
-  }
-
-  public static class Main {
-
-    public static void main(String[] args) {
-      A.apiLevel21();
-    }
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningNoInliningOfHigherApiLevelTest.java b/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningNoInliningOfHigherApiLevelTest.java
deleted file mode 100644
index 44263ba..0000000
--- a/src/test/java/com/android/tools/r8/apioutlining/ApiOutliningNoInliningOfHigherApiLevelTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (c) 2021, 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.apioutlining;
-
-import static com.android.tools.r8.apioutlining.ApiOutliningTestHelper.setMockApiLevelForMethod;
-import static com.android.tools.r8.apioutlining.ApiOutliningTestHelper.verifyThat;
-import static org.junit.Assert.assertThrows;
-
-import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestRunResult;
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import java.lang.reflect.Method;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-@RunWith(Parameterized.class)
-public class ApiOutliningNoInliningOfHigherApiLevelTest extends TestBase {
-
-  private final TestParameters parameters;
-
-  @Parameters(name = "{0}")
-  public static TestParametersCollection data() {
-    return getTestParameters().withAllRuntimes().withAllApiLevelsAlsoForCf().build();
-  }
-
-  public ApiOutliningNoInliningOfHigherApiLevelTest(TestParameters parameters) {
-    this.parameters = parameters;
-  }
-
-  @Test
-  public void testR8() throws Exception {
-    Method minApi = A.class.getDeclaredMethod("minApi");
-    Method apiLevel22 = B.class.getDeclaredMethod("apiLevel22");
-    R8TestRunResult runResult =
-        testForR8(parameters.getBackend())
-            .addInnerClasses(getClass())
-            .setMinApi(parameters.getApiLevel())
-            .addKeepMainRule(Main.class)
-            .enableInliningAnnotations()
-            .apply(setMockApiLevelForMethod(apiLevel22, AndroidApiLevel.L_MR1))
-            .run(parameters.getRuntime(), Main.class)
-            .assertSuccessWithOutputLines("A::minApi", "B::apiLevel22");
-    if (parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.L_MR1)) {
-      runResult.inspect(
-          verifyThat(parameters, apiLevel22)
-              .inlinedIntoFromApiLevel(minApi, AndroidApiLevel.L_MR1));
-    } else {
-      // TODO(b/188388130): Should only inline on minApi >= 22.
-      assertThrows(
-          AssertionError.class,
-          () ->
-              runResult.inspect(
-                  verifyThat(parameters, apiLevel22)
-                      .inlinedIntoFromApiLevel(minApi, AndroidApiLevel.L_MR1)));
-    }
-  }
-
-  public static class B {
-    public static void apiLevel22() {
-      System.out.println("B::apiLevel22");
-    }
-  }
-
-  public static class A {
-
-    @NeverInline
-    public static void minApi() {
-      System.out.println("A::minApi");
-      B.apiLevel22();
-    }
-  }
-
-  public static class Main {
-
-    public static void main(String[] args) {
-      A.minApi();
-    }
-  }
-}