commit a27800015eeb9e3c059c2f989ceb9b04ce1b721f
author Rico Wind <ricow@google.com> Thu Sep 09 13:14:31 2021 +0200
committer Rico Wind <ricow@google.com> Fri Sep 10 08:56:33 2021 +0000
tree 9311965a886cf117d5ef57a8ea486f40abede7a7
parent 7b4ad2acf9fedac356fbf15f0d99f2d722b2359d

Fix test of inlining targets with non resolved methods

The current test is actually testing if we inline into a method instead (same as the other test)

This is already handled correctly by the inliner, i.e., we don't inline this

Change-Id: I193cec06655c64e72b5b1b29c29d636b7c1a7ad2

src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress199142666.java

diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress199142666.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress199142666.java
index 1b31ea7..e92f84a 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress199142666.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress199142666.java
@@ -37,44 +37,43 @@
     return transformer(VirtualA.class).setClassDescriptor(descriptor(StaticA.class)).transform();
   }
 
-  private byte[] getStaticAAsVirtualA() throws IOException {
-    return transformer(StaticA.class).setClassDescriptor(descriptor(VirtualA.class)).transform();
-  }
-
   @Test
-  public void testInliningWhenInvalidTarget() throws Exception {
+  public void testInliningWhenInvalidCaller() throws Exception {
     R8TestRunResult run =
         testForR8(parameters.getBackend())
-            .addProgramClasses(B.class)
+            .addProgramClasses(HasInvalidStaticCall.class)
             .addProgramClassFileData(getVirtualAAsStaticA())
-            .addKeepMainRule(B.class)
+            .addKeepMainRule(HasInvalidStaticCall.class)
             .addKeepMethodRules(StaticA.class, "void foo()")
             .setMinApi(parameters.getApiLevel())
-            .run(parameters.getRuntime(), B.class);
+            .run(parameters.getRuntime(), HasInvalidStaticCall.class);
     if (parameters.getRuntime().asDex().getVm().getVersion().isDalvik()) {
       // TODO(b/199142666): We should not inline to provoke this error.
       run.assertFailureWithErrorThatMatches(
           containsString("invoke type does not match method type of"));
     } else {
+      // TODO(b/199142666): We should consider if we want to inline in this case (there are no
+      // verification errors)
       run.assertSuccessWithOutputLines("foochanged")
-          .inspect(inspector -> ensureThisNumberOfCalls(inspector, B.class));
+          .inspect(inspector -> ensureThisNumberOfCalls(inspector, HasInvalidStaticCall.class, 2));
     }
   }
 
   @Test
-  public void testInliningWhenInvalidCaller() throws Exception {
+  public void testInliningWhenInvalidTarget() throws Exception {
     testForR8(parameters.getBackend())
-        .addProgramClasses(C.class)
-        .addProgramClassFileData(getStaticAAsVirtualA())
-        .addKeepMainRule(C.class)
-        .addKeepMethodRules(VirtualA.class, "static void foo()")
+        .addProgramClasses(TargetHasInvalidStaticCall.class, CallsStaticFoo.class)
+        .addProgramClassFileData(getVirtualAAsStaticA())
+        .addKeepMainRule(TargetHasInvalidStaticCall.class)
+        .addKeepMethodRules(StaticA.class, "void foo()")
         .setMinApi(parameters.getApiLevel())
-        .run(parameters.getRuntime(), C.class)
-        .assertSuccessWithOutputLines("foo")
-        .inspect(inspector -> ensureThisNumberOfCalls(inspector, C.class));
+        .run(parameters.getRuntime(), TargetHasInvalidStaticCall.class)
+        .assertSuccessWithEmptyOutput()
+        .inspect(
+            inspector -> ensureThisNumberOfCalls(inspector, TargetHasInvalidStaticCall.class, 1));
   }
 
-  private void ensureThisNumberOfCalls(CodeInspector inspector, Class clazz) {
+  private void ensureThisNumberOfCalls(CodeInspector inspector, Class clazz, int fooCalls) {
     long count =
         inspector
             .clazz(clazz)
@@ -83,8 +82,7 @@
             .filter(InstructionSubject::isInvoke)
             .filter(invoke -> invoke.getMethod().name.toString().equals("foo"))
             .count();
-    // TODO(b/199142666): We should not inline, so count should be 1.
-    assertEquals(2, count);
+    assertEquals(fooCalls, count);
   }
 
   static class StaticA {
@@ -107,7 +105,13 @@
     }
   }
 
-  static class B {
+  static class CallsStaticFoo {
+    public static void callStaticFoo() {
+      StaticA.foo();
+    }
+  }
+
+  static class HasInvalidStaticCall {
     public static void main(String[] args) {
       StaticA.callFoo();
       try {
@@ -120,11 +124,19 @@
     }
   }
 
-  static class C {
+  static class TargetHasInvalidStaticCall {
     public static void main(String[] args) {
-      VirtualA.callFoo();
+      boolean didThrow = false;
       try {
-        new VirtualA().foo();
+        CallsStaticFoo.callStaticFoo();
+      } catch (IncompatibleClassChangeError e) {
+        didThrow = true;
+      }
+      if (!didThrow) {
+        throw new RuntimeException("Should have thrown ICCE");
+      }
+      try {
+        StaticA.foo();
       } catch (IncompatibleClassChangeError e) {
         return;
       }