test/hotspot/jtreg/runtime/Nestmates/reflectionAPI/TestReflectionAPI.java

@@ -28,10 +28,11 @@
  * @compile TestReflectionAPI.java
  *          PackagedNestHost.java
  *          PackagedNestHost2.java
  *          SampleNest.java
  *          Hosts.java
+ *          InvalidNestHost.java
  *
  * @compile MemberNoHost.jcod
  *          MemberMissingHost.jcod
  *          MemberNotInstanceHost.jcod
  *          MemberNotOurHost.jcod

@@ -43,10 +44,12 @@
  *          HostOfMemberNoHost.jcod
  *          HostOfMemberMissingHost.jcod
  *          HostOfMemberNotInstanceHost.jcod
  *          HostOfMemberNotOurHost.jcod
  *          HostOfMemberMalformedHost.jcod
+ *          HostWithSelfMember.jcod
+ *          HostWithDuplicateMembers.jcod
  *
  * @run main/othervm TestReflectionAPI
  */
 
 // We need a nest member class that is invalid for each of the possible reasons,

@@ -59,10 +62,11 @@
 // Note that all the .java files must be compiled in the same step, while all
 // .jcod files must be compiled in a later step.
 
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.HashSet;
 
 public class TestReflectionAPI {
 
     // Valid nest member
     static class Member {}

@@ -152,11 +156,22 @@
         // Sampling of "good" checks
         Class<?>[] good = { Object.class, Object[].class, int.class};
         checkSingletonNests(good);
 
         // More thorough correctness check
-        checkNest(SampleNest.class, SampleNest.nestedTypes());
+        checkNest(SampleNest.class, SampleNest.nestedTypes(), false);
+
+        // Special cases - legal but not produced by javac
+        checkNest(HostWithSelfMember.class,
+                  new Class<?>[] { HostWithSelfMember.class,
+                          HostWithSelfMember.Member.class },
+                  true);
+        checkNest(HostWithDuplicateMembers.class,
+                  new Class<?>[] { HostWithDuplicateMembers.class,
+                          HostWithDuplicateMembers.Member1.class,
+                          HostWithDuplicateMembers.Member2.class },
+                  true);
 
         // Hosts with "bad" members
         Class<?>[] bad = {
             HostOfMemberNoHost.class,
             HostOfMemberMissingHost.class,

@@ -175,13 +190,13 @@
             "Nest member HostOfMemberNoHost$MemberNoHost in HostOfMemberNoHost " +
             "declares a different nest host of HostOfMemberNoHost$MemberNoHost",
             "Unable to load nest-host class (NestHost) of " +
             "HostOfMemberMissingHost$MemberMissingHost",
             "Type HostOfMemberNotOurHost$MemberNotOurHost is not a nest member " +
-            "of java.lang.Object: current type is not listed as a nest member",
+            "of InvalidNestHost: current type is not listed as a nest member",
             "Type HostOfMemberNotInstanceHost$MemberNotInstanceHost is not a nest " +
-            "member of [Ljava.lang.Object;: nest-host is not an instance class!",
+            "member of [LInvalidNestHost;: current type is not listed as a nest member",
             "Incompatible magic value 3735928559 in class file MalformedHost",
         };
         for (int i = 0; i < bad.length; i++) {
             try {
                 bad[i].getNestMembers();

@@ -224,21 +239,33 @@
                             (mates ? "" : "not ") + "be");
     }
 
     static Comparator<Class<?>> cmp = Comparator.comparing(Class::getName);
 
-    static void checkNest(Class<?> host, Class<?>[] unsortedTypes) {
+    static void checkNest(Class<?> host, Class<?>[] unsortedTypes, boolean expectDups) {
         Class<?>[] members = host.getNestMembers();
         Arrays.sort(members, cmp);
         Class<?>[] nestedTypes = unsortedTypes.clone();
         Arrays.sort(nestedTypes, cmp);
         printMembers(host, members);
         printDeclared(host, nestedTypes);
         if (!Arrays.equals(members, nestedTypes)) {
+            if (!expectDups) {
             throw new Error("Class " + host.getName() + " has different members " +
                             "compared to declared classes");
         }
+            else {
+                // get rid of duplicates
+                Class<?>[] memberSet =
+                    new HashSet<Class<?>>(Arrays.asList(members)).toArray(new Class<?>[0]);
+                Arrays.sort(memberSet, cmp);
+                if (!Arrays.equals(memberSet, nestedTypes)) {
+                    throw new Error("Class " + host.getName() + " has different members " +
+                                "compared to declared classes, even after duplicate removal");
+                }
+            }
+        }
         // verify all the relationships that must hold for nest members
         for (Class<?> a : members) {
             checkHost(a, host);
             checkNestmates(a, host, true);
             Class<?>[] aMembers = a.getNestMembers();