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

*** 28,37 ****
--- 28,38 ----
   * @compile TestReflectionAPI.java
   *          PackagedNestHost.java
   *          PackagedNestHost2.java
   *          SampleNest.java
   *          Hosts.java
+  *          InvalidNestHost.java
   *
   * @compile MemberNoHost.jcod
   *          MemberMissingHost.jcod
   *          MemberNotInstanceHost.jcod
   *          MemberNotOurHost.jcod
*** 43,52 ****
--- 44,55 ----
   *          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,68 ****
--- 62,72 ----
  // 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,162 ****
          // Sampling of "good" checks
          Class<?>[] good = { Object.class, Object[].class, int.class};
          checkSingletonNests(good);
  
          // More thorough correctness check
!         checkNest(SampleNest.class, SampleNest.nestedTypes());
  
          // Hosts with "bad" members
          Class<?>[] bad = {
              HostOfMemberNoHost.class,
              HostOfMemberMissingHost.class,
--- 156,177 ----
          // Sampling of "good" checks
          Class<?>[] good = { Object.class, Object[].class, int.class};
          checkSingletonNests(good);
  
          // More thorough correctness check
!         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,187 ****
              "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",
              "Type HostOfMemberNotInstanceHost$MemberNotInstanceHost is not a nest " +
!             "member of [Ljava.lang.Object;: nest-host is not an instance class!",
              "Incompatible magic value 3735928559 in class file MalformedHost",
          };
          for (int i = 0; i < bad.length; i++) {
              try {
                  bad[i].getNestMembers();
--- 190,202 ----
              "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 InvalidNestHost: current type is not listed as a nest member",
              "Type HostOfMemberNotInstanceHost$MemberNotInstanceHost is not a nest " +
!             "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,244 ****
                              (mates ? "" : "not ") + "be");
      }
  
      static Comparator<Class<?>> cmp = Comparator.comparing(Class::getName);
  
!     static void checkNest(Class<?> host, Class<?>[] unsortedTypes) {
          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)) {
              throw new Error("Class " + host.getName() + " has different members " +
                              "compared to declared classes");
          }
          // 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();
--- 239,271 ----
                              (mates ? "" : "not ") + "be");
      }
  
      static Comparator<Class<?>> cmp = Comparator.comparing(Class::getName);
  
!     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();