--- /dev/null 2018-04-28 00:26:07.190086997 -0400 +++ new/test/hotspot/jtreg/runtime/Nestmates/reflectionAPI/TestReflectionAPI.java 2018-05-18 03:34:23.195168326 -0400 @@ -0,0 +1,319 @@ +/* + * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8046171 + * @summary Test the new nestmate reflection API + * @compile TestReflectionAPI.java + * PackagedNestHost.java + * PackagedNestHost2.java + * SampleNest.java + * Hosts.java + * InvalidNestHost.java + * + * @compile MemberNoHost.jcod + * MemberMissingHost.jcod + * MemberNotInstanceHost.jcod + * MemberNotOurHost.jcod + * MemberMalformedHost.jcod + * MalformedHost.jcod + * PackagedNestHost.jcod + * PackagedNestHost2Member.jcod + * PackagedNestHostMember.jcod + * HostOfMemberNoHost.jcod + * HostOfMemberMissingHost.jcod + * HostOfMemberNotInstanceHost.jcod + * HostOfMemberNotOurHost.jcod + * HostOfMemberMalformedHost.jcod + * HostWithSelfMember.jcod + * HostWithDuplicateMembers.jcod + * + * @run main/othervm TestReflectionAPI + * @run main/othervm/java.security.policy=empty.policy TestReflectionAPI + */ + +// We need a nest member class that is invalid for each of the possible reasons, +// plus we need some external classes to test other failure modes. +// For each nested class below there is a corresponding .jcod file which breaks one +// of the rules regarding nest membership. For the package related tests we have +// additional PackageNestHost*.java sources. +// For testing getNestMembers we need an external host class that has a nested class +// which we can form a jcod file from such that we get all the expected failure modes. +// 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 {} + + // Missing NestHost attribute + static class MemberNoHost {} + + // Missing NestHost class + static class MemberMissingHost {} + + // Invalid NestHost class (not instance class) + static class MemberNotInstanceHost { + Object[] oa; // create CP entry to use in jcod change + } + + // Valid but different NestHost class + static class MemberNotOurHost {} + + // Malformed NestHost class + static class MemberMalformedHost {} + + public static void main(String[] args) throws Throwable { + test_getNestHost(); + test_isNestmateOf(); + test_getNestMembers(); + } + + static void test_getNestHost() { + Class host = TestReflectionAPI.class; + + // sampling of "good" checks + + checkHost(host, host); + checkHost(Member.class, host); + Runnable r = new Runnable() { public void run() {}}; + checkHost(r.getClass(), host); + + // all the "bad" classes should report themselves as their + // own nest host - no exceptions should be thrown + Class[] allClasses = host.getDeclaredClasses(); + for (Class c : allClasses) { + if (c == Member.class) + continue; + checkHost(c, c); + } + checkHost(P1.PackagedNestHost.Member.class, + P1.PackagedNestHost.Member.class); + checkHost(P2.PackagedNestHost2.Member.class, + P2.PackagedNestHost2.Member.class); + + // test some 'special' classes + checkHost(int.class, int.class); // primitive + checkHost(Object[].class, Object[].class); // array + checkHost(Thread.State.class, Thread.class); // enum + checkHost(java.lang.annotation.Documented.class, // annotation + java.lang.annotation.Documented.class); + } + + static void test_isNestmateOf() { + Class host = TestReflectionAPI.class; + checkNestmates(host, host, true); + checkNestmates(Member.class, host, true); + Runnable r = new Runnable() { public void run() {}}; + checkNestmates(r.getClass(), host, true); + + // all the "bad" classes should report themselves as their + // own nest host - no exceptions should be thrown - so not + // nestmates + Class[] allClasses = host.getDeclaredClasses(); + for (Class c : allClasses) { + if (c == Member.class) + continue; + checkNestmates(host, c, false); + } + + // 'special' classes + checkNestmates(int.class, int.class, true); // primitive + checkNestmates(int.class, long.class, false); // primitive + checkNestmates(Object[].class, Object[].class, true); // array + checkNestmates(Object[].class, int[].class, false); // array + checkNestmates(Thread.State.class, Thread.class, true); // enum + checkNestmates(java.lang.annotation.Documented.class, // annotation + java.lang.annotation.Documented.class, true); + } + + static void test_getNestMembers() { + // 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, + HostOfMemberNotOurHost.class, + HostOfMemberNotInstanceHost.class, + HostOfMemberMalformedHost.class, + }; + Class[] exceptions = { + IncompatibleClassChangeError.class, + NoClassDefFoundError.class, + IncompatibleClassChangeError.class, + IncompatibleClassChangeError.class, + ClassFormatError.class, + }; + String[] messages = { + "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(); + throw new Error("getNestMembers() succeeded for class " + + bad[i].getName()); + } catch (LinkageError e) { + checkException(e, messages[i], exceptions[i]); + } + } + } + + static void checkException(Throwable actual, String msg, Class expected) { + if (!actual.getClass().equals(expected)) + throw new Error("Unexpected exception: got " + actual.getClass().getName() + + " but expected " + expected.getName()); + if (!actual.getMessage().contains(msg)) + throw new Error("Wrong " + actual.getClass().getSimpleName() +": \"" + + actual.getMessage() + "\" does not contain \"" + + msg + "\""); + System.out.println("OK - got expected exception: " + actual); + } + + static void checkHost(Class target, Class expected) { + System.out.println("Checking nest host of " + target.getName()); + Class host = target.getNestHost(); + if (host != expected) + throw new Error("Class " + target.getName() + + " has nest host " + host.getName() + + " but expected " + expected.getName()); + } + + static void checkNestmates(Class a, Class b, boolean mates) { + System.out.println("Checking if " + a.getName() + + " isNestmateOf " + b.getName()); + + if (a.isNestmateOf(b) != mates) + throw new Error("Class " + a.getName() + " is " + + (mates ? "not " : "") + + "a nestmate of " + b.getName() + " but should " + + (mates ? "" : "not ") + "be"); + } + + static Comparator> 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>(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(); + if (aMembers[0] != host) { + throw new Error("Class " + a.getName() + " getNestMembers()[0] = " + + aMembers[0].getName() + " not " + host.getName()); + + } + Arrays.sort(aMembers, cmp); + if (!Arrays.equals(members, aMembers)) { + throw new Error("Class " + a.getName() + " has different members " + + "compared to host " + host.getName()); + } + for (Class b : members) { + checkNestmates(a, b, true); + } + } + } + + static void checkSingletonNests(Class[] classes) { + for (Class host : classes) { + Class[] members = host.getNestMembers(); + if (members.length != 1) { + printMembers(host, members); + throw new Error("Class " + host.getName() + " lists " + members.length + + " members instead of 1 (itself)"); + } + if (members[0] != host) { + printMembers(host, members); + throw new Error("Class " + host.getName() + " lists " + + members[0].getName() + " as member instead of itself"); + } + } + } + + static void printMembers(Class host, Class[] members) { + System.out.println("Class " + host.getName() + " has members: "); + for (Class c : members) { + System.out.println(" - " + c.getName()); + } + } + + static void printDeclared(Class host, Class[] declared) { + System.out.println("Class " + host.getName() + " has declared types: "); + for (Class c : declared) { + System.out.println(" - " + c.getName()); + } + } + +}