test/java/lang/Class/getMethods/StarInheritance.java

@@ -28,10 +28,13 @@
  */
 
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 // D.m
 interface A1 extends B1, C1 {}
 interface B1 extends D1 {}
 interface C1 extends D1 {}

@@ -53,25 +56,45 @@
 interface A4 extends B4, C4 {}
 interface B4 extends D4 { void m(); }
 interface C4 extends D4 {}
 interface D4 { void m(); }
 
+// D.m
+abstract class A_1 extends B_1 implements C1 {}
+abstract class B_1 implements D1 {}
+
+// A_.m
+abstract class A_2 extends B_2 implements C2 { public abstract void m(); }
+abstract class B_2 implements D2 {}
+
+// B_.m, C.m
+abstract class A_3 extends B_3 implements C3 {}
+abstract class B_3 implements D3 { public abstract void m(); }
+
+// B_.m, D.m
+abstract class A_4 extends B_4 implements C4 {}
+abstract class B_4 implements D4 { public abstract void m(); }
+
 public class StarInheritance {
     private static int n = 1;
 
-    private static void test(Method [] ma, ArrayList expect) {
+    private static void test(Method [] ma, ArrayList<Class<?>> expect) {
+        // filter out Object methods
+        List<Method> ml = Stream.of(ma)
+            .filter(m -> m.getDeclaringClass() != Object.class)
+            .collect(Collectors.toList());
+
         System.out.println("Test " + n++);
 
-        if (expect.size() != ma.length) {
-            System.err.println("  found methods: " + Arrays.asList(ma));
+        if (expect.size() != ml.size()) {
+            System.err.println("  found methods: " + ml);
             System.err.println("  expected locations: " + expect);
-            throw new RuntimeException("found = " + ma.length
+            throw new RuntimeException("found = " + ml.size()
                                        +"; expected = " + expect.size());
         }
 
-        for (int i = 0; i < ma.length; i++) {
-            Method m = ma[i];
+        for (Method m : ml) {
             System.out.println("  " + m.toString());
             int n;
             if (m.getName().equals("m")
                 && (n = expect.indexOf(m.getDeclaringClass())) != -1) {
                 expect.remove(n);

@@ -81,18 +104,30 @@
             }
         }
     }
 
     public static void main(String [] args) {
-        Class [] l1 = {D1.class};
-        test(A1.class.getMethods(), new ArrayList(Arrays.asList(l1)));
+        Class<?> [] l1 = {D1.class};
+        test(A1.class.getMethods(), new ArrayList<>(Arrays.asList(l1)));
+
+        Class<?> [] l2 = {A2.class};
+        test(A2.class.getMethods(), new ArrayList<>(Arrays.asList(l2)));
+
+        Class<?> [] l3 = {B3.class, C3.class};
+        test(A3.class.getMethods(), new ArrayList<>(Arrays.asList(l3)));
+
+        Class<?> [] l4 = {B4.class, D4.class};
+        test(A4.class.getMethods(), new ArrayList<>(Arrays.asList(l4)));
+
+        Class<?> [] l_1 = {D1.class};
+        test(A_1.class.getMethods(), new ArrayList<>(Arrays.asList(l_1)));
 
-        Class [] l2 = {A2.class};
-        test(A2.class.getMethods(), new ArrayList(Arrays.asList(l2)));
+        Class<?> [] l_2 = {A_2.class};
+        test(A_2.class.getMethods(), new ArrayList<>(Arrays.asList(l_2)));
 
-        Class [] l3 = {B3.class, C3.class};
-        test(A3.class.getMethods(), new ArrayList(Arrays.asList(l3)));
+        Class<?> [] l_3 = {B_3.class, C3.class};
+        test(A_3.class.getMethods(), new ArrayList<>(Arrays.asList(l_3)));
 
-        Class [] l4 = {B4.class, D4.class};
-        test(A4.class.getMethods(), new ArrayList(Arrays.asList(l4)));
+        Class<?> [] l_4 = {B_4.class, D4.class};
+        test(A_4.class.getMethods(), new ArrayList<>(Arrays.asList(l_4)));
     }
 }