1 files changed, 179 insertions, 0 deletions
diff --git a/test/840-resolution/src/Main.java b/test/840-resolution/src/Main.java
new file mode 100644
index 0000000000..23cd31d3ab
--- /dev/null
+++ b/test/840-resolution/src/Main.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+
+  // Testcase 1: the superclass has a package private version in the same package.
+  static Interface s = new SubClass();
+
+  // Testcase 2: the class has a package private version.
+  static Interface s2;
+
+  // Testcase 3: the superclass has a package private version in a different package.
+  static Interface s3 = new SubClassFromPkg();
+
+  // Testcase 4: there is no implementation in the hierarchy.
+  static Interface s4 = new SubClassNoFoo();
+
+  // Testcase 5: there is a private method in the hierarchy.
+  static Interface s5 = new SubClassPrivateFoo();
+
+  // Testcase 6: there is a static method in the hierarchy.
+  static Interface s6 = new SubClassStaticFoo();
+
+  static {
+    try {
+      s2 = (Interface) Class.forName("SubClass2").newInstance();
+    } catch (Exception e) {
+      throw new Error(e);
+    }
+  }
+
+  public static void assertEquals(Object expected, Object actual) {
+    if (expected != actual) {
+      throw new Error("Expected " + expected + ", got " + actual);
+    }
+  }
+
+  public static void assertTrue(boolean value) {
+    if (!value) {
+      throw new Error("");
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    assertEquals(SuperClass.class, ((SubClass) s).foo());
+    assertEquals(SuperClass.class, ((SuperClass) s).foo());
+
+    try {
+      s.foo();
+      throw new Error("Expected IllegalAccessError");
+    } catch (IllegalAccessError ie) {
+      // expected
+    }
+
+    assertEquals(null, ((SuperClass) s2).foo());
+    try {
+      s2.foo();
+      throw new Error("Expected IllegalAccessError");
+    } catch (IllegalAccessError ie) {
+      // expected
+    }
+
+    try {
+      ((pkg.PkgSuperClass) s3).foo();
+      throw new Error("Expected IllegalAccessError");
+    } catch (IllegalAccessError ie) {
+      // expected
+    }
+
+    try {
+      ((SubClassFromPkg) s3).foo();
+      throw new Error("Expected IllegalAccessError");
+    } catch (IllegalAccessError ie) {
+      // expected
+    }
+
+    try {
+      s3.foo();
+      throw new Error("Expected IllegalAccessError");
+    } catch (IllegalAccessError ie) {
+      // expected
+    }
+
+    try {
+      ((SuperClassNoFoo) s4).foo();
+      throw new Error("Expected NoSuchMethodError");
+    } catch (NoSuchMethodError e) {
+      // expected
+    }
+
+    try {
+      ((SubClassNoFoo) s4).foo();
+      throw new Error("Expected AbstractMethodError");
+    } catch (AbstractMethodError e) {
+      // expected
+    }
+
+    try {
+      s4.foo();
+      throw new Error("Expected AbstractMethodError");
+    } catch (AbstractMethodError e) {
+      // expected
+    }
+
+    try {
+      ((SuperClassPrivateFoo) s5).foo();
+      throw new Error("Expected IllegalAccessError");
+    } catch (IllegalAccessError e) {
+      // expected
+    }
+
+    try {
+      ((SubClassPrivateFoo) s5).foo();
+      throw new Error("Expected IllegalAccessError");
+    } catch (IllegalAccessError e) {
+      // expected
+    }
+
+    try {
+      s5.foo();
+      throw new Error("Expected AbstractMethodError on RI, IllegalAccessError on ART");
+    } catch (AbstractMethodError | IllegalAccessError e) {
+      // expected
+    }
+
+    try {
+      ((SuperClassStaticFoo) s6).foo();
+      throw new Error("Expected IncompatibleClassChangeError");
+    } catch (IncompatibleClassChangeError e) {
+      // expected
+    }
+
+    try {
+      ((SubClassStaticFoo) s6).foo();
+      throw new Error("Expected IncompatibleClassChangeError");
+    } catch (IncompatibleClassChangeError e) {
+      // expected
+    }
+
+    try {
+      s6.foo();
+      throw new Error("Expected AbstractMethodError");
+    } catch (AbstractMethodError e) {
+      // expected
+    }
+  }
+}
+
+interface Interface {
+  public Class<?> foo();
+}
+
+class SubClass extends SuperClass implements Interface {
+}
+
+class SubClassFromPkg extends pkg.PkgSuperClass implements Interface {
+}
+
+class SubClassNoFoo extends SuperClassNoFoo implements Interface {
+}
+
+class SubClassPrivateFoo extends SuperClassPrivateFoo implements Interface {
+}
+
+class SubClassStaticFoo extends SuperClassStaticFoo implements Interface {
+}