--- old/test/hotspot/jtreg/runtime/Nestmates/membership/TestNestmateMembership.java 2017-10-26 03:07:25.696897527 -0400 +++ new/test/hotspot/jtreg/runtime/Nestmates/membership/TestNestmateMembership.java 2017-10-26 03:07:24.060804060 -0400 @@ -28,13 +28,19 @@ * @compile TestNestmateMembership.java * PackagedNestHost.java * PackagedNestHost2.java - * NotAMember2.java - * @compile MissingNestHost.jcod - * ArrayNestHost.jcod - * NotAMember.jcod - * NotAMember2.jcod + * + * @compile TargetNoHost.jcod + * CallerNoHost.jcod + * TargetMissingHost.jcod + * CallerMissingHost.jcod + * CallerNotInstanceHost.jcod + * TargetNotInstanceHost.jcod + * CallerNotOurHost.jcod + * TargetNotOurHost.jcod * PackagedNestHost.jcod * PackagedNestHost2Member.jcod + * PackagedNestHostMember.jcod + * * @run main/othervm TestNestmateMembership */ @@ -44,120 +50,311 @@ // be a way to construct that scenario. // 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. We also have NotAMember2.java. +// additional PackageNestHost*.java sources. // Note that all the .java files must be compiled in the same step, while all // .jcod files must be compiled in a later step. +// As access checking requires resolution and validation of the nest-host of +// both the caller class and the target class, we must check that all +// combinations of good/bad caller/target are checked for each of the +// possible errors: +// - no nest-host attribute +// - nest-host class can not be found +// - nest-host class is not an instance class +// - class is not a member of nest-host's nest +// - class and nest-host are in different packages + public class TestNestmateMembership { - // jcod modified to have non-existent nest-host - static class MissingNestHost { + static class Caller { + private static void m() { + System.out.println("Caller.m()"); + } + public static void invokeTarget() { + Target.m(); + } + public static void invokeTargetNoHost() { + TargetNoHost.m(); + } + public static void invokeTargetMissingHost() { + TargetMissingHost.m(); + } + public static void invokeTargetNotInstanceHost() { + TargetNotInstanceHost.m(); + } + public static void invokeTargetNotOurHost() { + TargetNotOurHost.m(); + } + } + + static class CallerNoHost { + private static void m() { + System.out.println("CallerNoHost.m() - java version"); + } + public static void invokeTarget() { + Target.m(); + } + public static void invokeTargetNoHost() { + TargetNoHost.m(); + } + } + + static class CallerMissingHost { + String msg = "NoCallerMissingHost"; // for cp entry + private static void m() { + System.out.println("CallerMissingHost.m() - java version"); + } + public static void invokeTarget() { + Target.m(); + } + public static void invokeTargetMissingHost() { + TargetMissingHost.m(); + } + } + + static class CallerNotInstanceHost { + Object[] oa; // create CP entry to use in jcod change + private static void m() { + System.out.println("CallerNotInstanceHost.m() - java version"); + } + public static void invokeTarget() { + Target.m(); + } + public static void invokeTargetNotInstanceHost() { + TargetNotInstanceHost.m(); + } + } + + static class CallerNotOurHost { + private static void m() { + System.out.println("CallerNotOurHost.m() - java version"); + } + public static void invokeTarget() { + Target.m(); + } + public static void invokeTargetNotOurHost() { + TargetNotOurHost.m(); + } + } + + static class Target { + private static void m() { + System.out.println("Target.m()"); + } + } + + static class TargetNoHost { + private static void m() { + System.out.println("TargetNoHost.m() - java version"); + } + } + + static class TargetMissingHost { + String msg = "NoTargetMissingHost"; // for cp entry private static void m() { - System.out.println("MissingNestHost.m() - java version"); + System.out.println("TargetMissingHost.m() - java version"); } } - // jcod modified to have non-instance class Object[] as nest-host - static class ArrayNestHost { - Object[] oa; // create CP entry + static class TargetNotInstanceHost { + Object[] oa; // create CP entry to use in jcod change private static void m() { - System.out.println("ArrayNestHost.m() - java version"); + System.out.println("TargetNotInstanceHost.m() - java version"); } } - // jcod modified to have Object as nest-host, which has no nest-members - static class NotAMember { + static class TargetNotOurHost { private static void m() { - System.out.println("NotAMember.m() - java version"); + System.out.println("TargetNotOurHost.m() - java version"); } } public static void main(String[] args) throws Throwable { - test_MissingNestHost(); - test_ArrayNestHost(); - test_WrongPackageForNestMember(); - test_NotAMember(); - test_NotAMember2(); + test_GoodCalls(); + test_NoHost(); + test_MissingHost(); + test_NotInstanceHost(); + test_NotOurHost(); + test_WrongPackageHost(); } - static void test_WrongPackageForNestMember() { - System.out.println("Testing for nest-host and nest-member in different packages"); - String msg = "Class P2.PackagedNestHost2$Member is in a different" + - " package to its nest-host class P1.PackagedNestHost"; + static void test_GoodCalls(){ try { - P1.PackagedNestHost.doAccess(); - throw new Error("Missing IncompatibleClassChangeError: " + msg); + Caller.invokeTarget(); } - catch (IncompatibleClassChangeError expected) { - if (!expected.getMessage().contains(msg)) - throw new Error("Wrong IncompatibleClassChangeError: \"" + - expected.getMessage() + "\" does not contain \"" + - msg + "\""); - System.out.println("OK - got expected exception: " + expected); + catch (Exception e) { + throw new Error("Unexpected exception on good calls: " + e); } } - static void test_MissingNestHost() throws Throwable { + static void test_NoHost() throws Throwable { + System.out.println("Testing for missing nest-host attribute"); + String msg = "tried to access method " + + "TestNestmateMembership$TargetNoHost.m()V from class " + + "TestNestmateMembership$Caller"; + try { + Caller.invokeTargetNoHost(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } + msg = "tried to access method TestNestmateMembership$Target.m()V" + + " from class TestNestmateMembership$CallerNoHost"; + try { + CallerNoHost.invokeTarget(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } + msg = "tried to access method TestNestmateMembership$TargetNoHost.m()V" + + " from class TestNestmateMembership$CallerNoHost"; + try { + CallerNoHost.invokeTargetNoHost(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } + } + + static void test_MissingHost() throws Throwable { System.out.println("Testing for nest-host class that does not exist"); - String msg = "NoSuchClass"; + String msg = "Unable to load nest-host class of " + + "TestNestmateMembership$TargetMissingHost"; + String cause_msg = "NoTargetMissingHost"; + try { + Caller.invokeTargetMissingHost(); + throw new Error("Missing NoClassDefFoundError: " + msg); + } + catch (NoClassDefFoundError expected) { + check_expected(expected, msg); + Throwable cause = expected.getCause(); + if (cause instanceof NoClassDefFoundError) { + check_expected(cause, cause_msg); + } + else throw new Error("Unexpected NoClassDefFoundError", expected); + } + msg = "Unable to load nest-host class of " + + "TestNestmateMembership$CallerMissingHost"; + cause_msg = "NoCallerMissingHost"; try { - MissingNestHost.m(); + CallerMissingHost.invokeTarget(); throw new Error("Missing NoClassDefFoundError: " + msg); } catch (NoClassDefFoundError expected) { - if (!expected.getMessage().contains(msg)) - throw new Error("Wrong NoClassDefFoundError: \"" + - expected.getMessage() + "\" does not contain \"" + - msg + "\""); - System.out.println("OK - got expected exception: " + expected); + check_expected(expected, msg); + Throwable cause = expected.getCause(); + if (cause instanceof NoClassDefFoundError) { + check_expected(cause, cause_msg); + } + else throw new Error("Unexpected NoClassDefFoundError", expected); + } + msg = "Unable to load nest-host class of "+ + "TestNestmateMembership$CallerMissingHost"; + cause_msg = "NoCallerMissingHost"; + try { + CallerMissingHost.invokeTargetMissingHost(); + throw new Error("Missing NoClassDefFoundError: " + msg); + } + catch (NoClassDefFoundError expected) { + check_expected(expected, msg); + Throwable cause = expected.getCause(); + if (cause instanceof NoClassDefFoundError) { + check_expected(cause, cause_msg); + } + else throw new Error("Unexpected NoClassDefFoundError", expected); } } - static void test_ArrayNestHost() throws Throwable { + static void test_NotInstanceHost() throws Throwable { System.out.println("Testing for nest-host class that is not an instance class"); - String msg = "ArrayNestHost has non-instance class [Ljava.lang.Object; as nest-host"; + String msg = "Type TestNestmateMembership$TargetNotInstanceHost is not a "+ + "nest member of [Ljava.lang.Object;: nest-host is not an instance class"; + try { + Caller.invokeTargetNotInstanceHost(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } + msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+ + "nest member of [Ljava.lang.Object;: nest-host is not an instance class"; + try { + CallerNotInstanceHost.invokeTarget(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } + msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+ + "nest member of [Ljava.lang.Object;: nest-host is not an instance class"; try { - ArrayNestHost.m(); - throw new Error("Missing IncompatibleClassChangeError: " + msg); + CallerNotInstanceHost.invokeTargetNotInstanceHost(); + throw new Error("Missing IllegalAccessError: " + msg); } - catch (IncompatibleClassChangeError expected) { - if (!expected.getMessage().contains(msg)) - throw new Error("Wrong IncompatibleClassChangeError: \"" + - expected.getMessage() + "\" does not contain \"" + - msg + "\""); - System.out.println("OK - got expected exception: " + expected); + catch (IllegalAccessError expected) { + check_expected(expected, msg); } } - static void test_NotAMember() throws Throwable { - System.out.println("Testing for nest-host class that has no nest"); - String msg = "NotAMember is not a nest member of java.lang.Object"; + static void test_NotOurHost() throws Throwable { + System.out.println("Testing for nest-host class that does not list us in its nest"); + String msg = "Type TestNestmateMembership$TargetNotOurHost is not a nest member" + + " of java.lang.Object: current type is not listed as a nest member"; + try { + Caller.invokeTargetNotOurHost(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } + msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" + + " of java.lang.Object: current type is not listed as a nest member"; try { - NotAMember.m(); - throw new Error("Missing IncompatibleClassChangeError: " + msg); + CallerNotOurHost.invokeTarget(); + throw new Error("Missing IllegalAccessError: " + msg); } - catch (IncompatibleClassChangeError expected) { - if (!expected.getMessage().contains(msg)) - throw new Error("Wrong IncompatibleClassChangeError: \"" + - expected.getMessage() + "\" does not contain \"" + - msg + "\""); - System.out.println("OK - got expected exception: " + expected); + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } + msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" + + " of java.lang.Object: current type is not listed as a nest member"; + try { + CallerNotOurHost.invokeTargetNotOurHost(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); } } - static void test_NotAMember2() throws Throwable { - System.out.println("Testing for nest-host class that doesn't list this class as a member"); - String msg = "NotAMember2$Member is not a nest member of TestNestmateMembership"; + static void test_WrongPackageHost() { + System.out.println("Testing for nest-host and nest-member in different packages"); + String msg = "Type P2.PackagedNestHost2$Member is not a nest member of " + + "P1.PackagedNestHost: types are in different packages"; + try { + P1.PackagedNestHost.doAccess(); + throw new Error("Missing IllegalAccessError: " + msg); + } + catch (IllegalAccessError expected) { + check_expected(expected, msg); + } try { - NotAMember2.Member.m(); - throw new Error("Missing IncompatibleClassChangeError: " + msg); + P2.PackagedNestHost2.Member.doAccess(); + throw new Error("Missing IllegalAccessError: " + msg); } - catch (IncompatibleClassChangeError expected) { - if (!expected.getMessage().contains(msg)) - throw new Error("Wrong IncompatibleClassChangeError: \"" + - expected.getMessage() + "\" does not contain \"" + - msg + "\""); - System.out.println("OK - got expected exception: " + expected); + catch (IllegalAccessError expected) { + check_expected(expected, msg); } } + + static void check_expected(Throwable expected, String msg) { + if (!expected.getMessage().contains(msg)) + throw new Error("Wrong " + expected.getClass().getSimpleName() +": \"" + + expected.getMessage() + "\" does not contain \"" + + msg + "\""); + System.out.println("OK - got expected exception: " + expected); + } }