test/hotspot/jtreg/runtime/Nestmates/membership/TestNestmateMembership.java
changeset 52706 19b15ff2576b
parent 50816 a73848f8d0ad
child 54432 532e88de77eb
equal deleted inserted replaced
52705:53a407ab6d22 52706:19b15ff2576b
   717         }
   717         }
   718     }
   718     }
   719 
   719 
   720     static void test_SelfHostInvoke() throws Throwable {
   720     static void test_SelfHostInvoke() throws Throwable {
   721         System.out.println("Testing for class that lists itself as nest-host");
   721         System.out.println("Testing for class that lists itself as nest-host");
   722         String msg = "Type TestNestmateMembership$TargetSelfHost is not a nest member" +
   722         String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
   723             " of TestNestmateMembership$TargetSelfHost: current type is not listed as a nest member";
   723             " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
   724         try {
   724         try {
   725             Caller.invokeTargetSelfHost();
   725             Caller.invokeTargetSelfHost();
   726             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   726             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   727         }
   727         }
   728         catch (IncompatibleClassChangeError expected) {
   728         catch (IncompatibleClassChangeError expected) {
   742         }
   742         }
   743         catch (IllegalAccessException expected) {
   743         catch (IllegalAccessException expected) {
   744             check_expected(expected, msg);
   744             check_expected(expected, msg);
   745         }
   745         }
   746 
   746 
   747         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
   747         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
   748             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
   748             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
   749         try {
   749         try {
   750             CallerSelfHost.invokeTarget();
   750             CallerSelfHost.invokeTarget();
   751             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   751             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   752         }
   752         }
   753         catch (IncompatibleClassChangeError expected) {
   753         catch (IncompatibleClassChangeError expected) {
   754             check_expected(expected, msg);
   754             check_expected(expected, msg);
   755         }
   755         }
   756         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
   756         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
   757             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
   757             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
   758         try {
   758         try {
   759             CallerSelfHost.invokeTargetSelfHost();
   759             CallerSelfHost.invokeTargetSelfHost();
   760             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   760             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   761         }
   761         }
   762         catch (IncompatibleClassChangeError expected) {
   762         catch (IncompatibleClassChangeError expected) {
   822         }
   822         }
   823     }
   823     }
   824 
   824 
   825     static void test_NotInstanceHostInvoke() throws Throwable {
   825     static void test_NotInstanceHostInvoke() throws Throwable {
   826         System.out.println("Testing for nest-host class that is not an instance class");
   826         System.out.println("Testing for nest-host class that is not an instance class");
   827         String msg = "Type TestNestmateMembership$TargetNotInstanceHost is not a "+
   827         String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
   828             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
   828             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
   829         try {
   829         try {
   830             Caller.invokeTargetNotInstanceHost();
   830             Caller.invokeTargetNotInstanceHost();
   831             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   831             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   832         }
   832         }
   833         catch (IncompatibleClassChangeError expected) {
   833         catch (IncompatibleClassChangeError expected) {
   847         }
   847         }
   848         catch (IllegalAccessException expected) {
   848         catch (IllegalAccessException expected) {
   849             check_expected(expected, msg);
   849             check_expected(expected, msg);
   850         }
   850         }
   851 
   851 
   852         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
   852         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
   853             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
   853             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
   854         try {
   854         try {
   855             CallerNotInstanceHost.invokeTarget();
   855             CallerNotInstanceHost.invokeTarget();
   856             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   856             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   857         }
   857         }
   858         catch (IncompatibleClassChangeError expected) {
   858         catch (IncompatibleClassChangeError expected) {
   859             check_expected(expected, msg);
   859             check_expected(expected, msg);
   860         }
   860         }
   861         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
   861         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
   862             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
   862             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
   863         try {
   863         try {
   864             CallerNotInstanceHost.invokeTargetNotInstanceHost();
   864             CallerNotInstanceHost.invokeTargetNotInstanceHost();
   865             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   865             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   866         }
   866         }
   867         catch (IncompatibleClassChangeError expected) {
   867         catch (IncompatibleClassChangeError expected) {
   869         }
   869         }
   870     }
   870     }
   871 
   871 
   872     static void test_NotOurHostInvoke() throws Throwable {
   872     static void test_NotOurHostInvoke() throws Throwable {
   873         System.out.println("Testing for nest-host class that does not list us in its nest");
   873         System.out.println("Testing for nest-host class that does not list us in its nest");
   874         String msg = "Type TestNestmateMembership$TargetNotOurHost is not a nest member" +
   874         String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
   875             " of InvalidNestHost: current type is not listed as a nest member";
   875             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
   876         try {
   876         try {
   877             Caller.invokeTargetNotOurHost();
   877             Caller.invokeTargetNotOurHost();
   878             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   878             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   879         }
   879         }
   880         catch (IncompatibleClassChangeError expected) {
   880         catch (IncompatibleClassChangeError expected) {
   894         }
   894         }
   895         catch (IllegalAccessException expected) {
   895         catch (IllegalAccessException expected) {
   896             check_expected(expected, msg);
   896             check_expected(expected, msg);
   897         }
   897         }
   898 
   898 
   899         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
   899         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
   900             " of InvalidNestHost: current type is not listed as a nest member";
   900             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
   901         try {
   901         try {
   902             CallerNotOurHost.invokeTarget();
   902             CallerNotOurHost.invokeTarget();
   903             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   903             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   904         }
   904         }
   905         catch (IncompatibleClassChangeError expected) {
   905         catch (IncompatibleClassChangeError expected) {
   906             check_expected(expected, msg);
   906             check_expected(expected, msg);
   907         }
   907         }
   908         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
   908         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
   909             " of InvalidNestHost: current type is not listed as a nest member";
   909             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
   910         try {
   910         try {
   911             CallerNotOurHost.invokeTargetNotOurHost();
   911             CallerNotOurHost.invokeTargetNotOurHost();
   912             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   912             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   913         }
   913         }
   914         catch (IncompatibleClassChangeError expected) {
   914         catch (IncompatibleClassChangeError expected) {
   916         }
   916         }
   917     }
   917     }
   918 
   918 
   919     static void test_WrongPackageHostInvoke() {
   919     static void test_WrongPackageHostInvoke() {
   920         System.out.println("Testing for nest-host and nest-member in different packages");
   920         System.out.println("Testing for nest-host and nest-member in different packages");
   921         String msg = "Type P2.PackagedNestHost2$Member is not a nest member of " +
   921         String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
   922             "P1.PackagedNestHost: types are in different packages";
   922             "P1.PackagedNestHost (loader: 'app'): types are in different packages";
   923         try {
   923         try {
   924             P1.PackagedNestHost.doInvoke();
   924             P1.PackagedNestHost.doInvoke();
   925             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   925             throw new Error("Missing IncompatibleClassChangeError: " + msg);
   926         }
   926         }
   927         catch (IncompatibleClassChangeError expected) {
   927         catch (IncompatibleClassChangeError expected) {
   996         }
   996         }
   997     }
   997     }
   998 
   998 
   999     static void test_SelfHostConstruct() throws Throwable {
   999     static void test_SelfHostConstruct() throws Throwable {
  1000         System.out.println("Testing for class that lists itself as nest-host");
  1000         System.out.println("Testing for class that lists itself as nest-host");
  1001         String msg = "Type TestNestmateMembership$TargetSelfHost is not a nest member" +
  1001         String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
  1002             " of TestNestmateMembership$TargetSelfHost: current type is not listed as a nest member";
  1002             " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
  1003         try {
  1003         try {
  1004             Caller.newTargetSelfHost();
  1004             Caller.newTargetSelfHost();
  1005             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1005             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1006         }
  1006         }
  1007         catch (IncompatibleClassChangeError expected) {
  1007         catch (IncompatibleClassChangeError expected) {
  1021         }
  1021         }
  1022         catch (IllegalAccessException expected) {
  1022         catch (IllegalAccessException expected) {
  1023             check_expected(expected, msg);
  1023             check_expected(expected, msg);
  1024         }
  1024         }
  1025 
  1025 
  1026         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
  1026         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
  1027             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
  1027             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
  1028         try {
  1028         try {
  1029             CallerSelfHost.newTarget();
  1029             CallerSelfHost.newTarget();
  1030             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1030             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1031         }
  1031         }
  1032         catch (IncompatibleClassChangeError expected) {
  1032         catch (IncompatibleClassChangeError expected) {
  1033             check_expected(expected, msg);
  1033             check_expected(expected, msg);
  1034         }
  1034         }
  1035         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
  1035         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
  1036             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
  1036             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
  1037         try {
  1037         try {
  1038             CallerSelfHost.newTargetSelfHost();
  1038             CallerSelfHost.newTargetSelfHost();
  1039             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1039             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1040         }
  1040         }
  1041         catch (IncompatibleClassChangeError expected) {
  1041         catch (IncompatibleClassChangeError expected) {
  1093         }
  1093         }
  1094     }
  1094     }
  1095 
  1095 
  1096     static void test_NotInstanceHostConstruct() throws Throwable {
  1096     static void test_NotInstanceHostConstruct() throws Throwable {
  1097         System.out.println("Testing for nest-host class that is not an instance class");
  1097         System.out.println("Testing for nest-host class that is not an instance class");
  1098         String msg = "Type TestNestmateMembership$TargetNotInstanceHost is not a "+
  1098         String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
  1099             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1099             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1100         try {
  1100         try {
  1101             Caller.newTargetNotInstanceHost();
  1101             Caller.newTargetNotInstanceHost();
  1102             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1102             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1103         }
  1103         }
  1104         catch (IncompatibleClassChangeError expected) {
  1104         catch (IncompatibleClassChangeError expected) {
  1118         }
  1118         }
  1119         catch (IllegalAccessException expected) {
  1119         catch (IllegalAccessException expected) {
  1120             check_expected(expected, msg);
  1120             check_expected(expected, msg);
  1121         }
  1121         }
  1122 
  1122 
  1123         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
  1123         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
  1124             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1124             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1125         try {
  1125         try {
  1126             CallerNotInstanceHost.newTarget();
  1126             CallerNotInstanceHost.newTarget();
  1127             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1127             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1128         }
  1128         }
  1129         catch (IncompatibleClassChangeError expected) {
  1129         catch (IncompatibleClassChangeError expected) {
  1130             check_expected(expected, msg);
  1130             check_expected(expected, msg);
  1131         }
  1131         }
  1132         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
  1132         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
  1133             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1133             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1134         try {
  1134         try {
  1135             CallerNotInstanceHost.newTargetNotInstanceHost();
  1135             CallerNotInstanceHost.newTargetNotInstanceHost();
  1136             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1136             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1137         }
  1137         }
  1138         catch (IncompatibleClassChangeError expected) {
  1138         catch (IncompatibleClassChangeError expected) {
  1140         }
  1140         }
  1141     }
  1141     }
  1142 
  1142 
  1143     static void test_NotOurHostConstruct() throws Throwable {
  1143     static void test_NotOurHostConstruct() throws Throwable {
  1144         System.out.println("Testing for nest-host class that does not list us in its nest");
  1144         System.out.println("Testing for nest-host class that does not list us in its nest");
  1145         String msg = "Type TestNestmateMembership$TargetNotOurHost is not a nest member" +
  1145         String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
  1146             " of InvalidNestHost: current type is not listed as a nest member";
  1146             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1147         try {
  1147         try {
  1148             Caller.newTargetNotOurHost();
  1148             Caller.newTargetNotOurHost();
  1149             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1149             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1150         }
  1150         }
  1151         catch (IncompatibleClassChangeError expected) {
  1151         catch (IncompatibleClassChangeError expected) {
  1165         }
  1165         }
  1166         catch (IllegalAccessException expected) {
  1166         catch (IllegalAccessException expected) {
  1167             check_expected(expected, msg);
  1167             check_expected(expected, msg);
  1168         }
  1168         }
  1169 
  1169 
  1170         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
  1170         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
  1171             " of InvalidNestHost: current type is not listed as a nest member";
  1171             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1172         try {
  1172         try {
  1173             CallerNotOurHost.newTarget();
  1173             CallerNotOurHost.newTarget();
  1174             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1174             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1175         }
  1175         }
  1176         catch (IncompatibleClassChangeError expected) {
  1176         catch (IncompatibleClassChangeError expected) {
  1177             check_expected(expected, msg);
  1177             check_expected(expected, msg);
  1178         }
  1178         }
  1179         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
  1179         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
  1180             " of InvalidNestHost: current type is not listed as a nest member";
  1180             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1181         try {
  1181         try {
  1182             CallerNotOurHost.newTargetNotOurHost();
  1182             CallerNotOurHost.newTargetNotOurHost();
  1183             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1183             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1184         }
  1184         }
  1185         catch (IncompatibleClassChangeError expected) {
  1185         catch (IncompatibleClassChangeError expected) {
  1187         }
  1187         }
  1188     }
  1188     }
  1189 
  1189 
  1190     static void test_WrongPackageHostConstruct() {
  1190     static void test_WrongPackageHostConstruct() {
  1191         System.out.println("Testing for nest-host and nest-member in different packages");
  1191         System.out.println("Testing for nest-host and nest-member in different packages");
  1192         String msg = "Type P2.PackagedNestHost2$Member is not a nest member of " +
  1192         String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
  1193             "P1.PackagedNestHost: types are in different packages";
  1193             "P1.PackagedNestHost (loader: 'app'): types are in different packages";
  1194         try {
  1194         try {
  1195             P1.PackagedNestHost.doConstruct();
  1195             P1.PackagedNestHost.doConstruct();
  1196             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1196             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1197         }
  1197         }
  1198         catch (IncompatibleClassChangeError expected) {
  1198         catch (IncompatibleClassChangeError expected) {
  1267         }
  1267         }
  1268     }
  1268     }
  1269 
  1269 
  1270     static void test_SelfHostGetField() throws Throwable {
  1270     static void test_SelfHostGetField() throws Throwable {
  1271         System.out.println("Testing for class that lists itself as nest-host");
  1271         System.out.println("Testing for class that lists itself as nest-host");
  1272         String msg = "Type TestNestmateMembership$TargetSelfHost is not a nest member" +
  1272         String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
  1273             " of TestNestmateMembership$TargetSelfHost: current type is not listed as a nest member";
  1273             " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
  1274         try {
  1274         try {
  1275             Caller.getFieldTargetSelfHost();
  1275             Caller.getFieldTargetSelfHost();
  1276             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1276             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1277         }
  1277         }
  1278         catch (IncompatibleClassChangeError expected) {
  1278         catch (IncompatibleClassChangeError expected) {
  1291         }
  1291         }
  1292         catch (IncompatibleClassChangeError expected) {
  1292         catch (IncompatibleClassChangeError expected) {
  1293             check_expected(expected, msg);
  1293             check_expected(expected, msg);
  1294         }
  1294         }
  1295 
  1295 
  1296         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
  1296         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
  1297             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
  1297             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
  1298         try {
  1298         try {
  1299             CallerSelfHost.getFieldTarget();
  1299             CallerSelfHost.getFieldTarget();
  1300             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1300             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1301         }
  1301         }
  1302         catch (IncompatibleClassChangeError expected) {
  1302         catch (IncompatibleClassChangeError expected) {
  1303             check_expected(expected, msg);
  1303             check_expected(expected, msg);
  1304         }
  1304         }
  1305         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
  1305         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
  1306             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
  1306             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
  1307         try {
  1307         try {
  1308             CallerSelfHost.getFieldTargetSelfHost();
  1308             CallerSelfHost.getFieldTargetSelfHost();
  1309             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1309             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1310         }
  1310         }
  1311         catch (IncompatibleClassChangeError expected) {
  1311         catch (IncompatibleClassChangeError expected) {
  1362         }
  1362         }
  1363     }
  1363     }
  1364 
  1364 
  1365     static void test_NotInstanceHostGetField() throws Throwable {
  1365     static void test_NotInstanceHostGetField() throws Throwable {
  1366         System.out.println("Testing for nest-host class that is not an instance class");
  1366         System.out.println("Testing for nest-host class that is not an instance class");
  1367         String msg = "Type TestNestmateMembership$TargetNotInstanceHost is not a "+
  1367         String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
  1368             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1368             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1369         try {
  1369         try {
  1370             Caller.getFieldTargetNotInstanceHost();
  1370             Caller.getFieldTargetNotInstanceHost();
  1371             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1371             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1372         }
  1372         }
  1373         catch (IncompatibleClassChangeError expected) {
  1373         catch (IncompatibleClassChangeError expected) {
  1386         }
  1386         }
  1387         catch (IncompatibleClassChangeError expected) {
  1387         catch (IncompatibleClassChangeError expected) {
  1388             check_expected(expected, msg);
  1388             check_expected(expected, msg);
  1389         }
  1389         }
  1390 
  1390 
  1391         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
  1391         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
  1392             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1392             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1393         try {
  1393         try {
  1394             CallerNotInstanceHost.getFieldTarget();
  1394             CallerNotInstanceHost.getFieldTarget();
  1395             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1395             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1396         }
  1396         }
  1397         catch (IncompatibleClassChangeError expected) {
  1397         catch (IncompatibleClassChangeError expected) {
  1398             check_expected(expected, msg);
  1398             check_expected(expected, msg);
  1399         }
  1399         }
  1400         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
  1400         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
  1401             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1401             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1402         try {
  1402         try {
  1403             CallerNotInstanceHost.getFieldTargetNotInstanceHost();
  1403             CallerNotInstanceHost.getFieldTargetNotInstanceHost();
  1404             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1404             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1405         }
  1405         }
  1406         catch (IncompatibleClassChangeError expected) {
  1406         catch (IncompatibleClassChangeError expected) {
  1408         }
  1408         }
  1409     }
  1409     }
  1410 
  1410 
  1411     static void test_NotOurHostGetField() throws Throwable {
  1411     static void test_NotOurHostGetField() throws Throwable {
  1412         System.out.println("Testing for nest-host class that does not list us in its nest");
  1412         System.out.println("Testing for nest-host class that does not list us in its nest");
  1413         String msg = "Type TestNestmateMembership$TargetNotOurHost is not a nest member" +
  1413         String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
  1414             " of InvalidNestHost: current type is not listed as a nest member";
  1414             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1415         try {
  1415         try {
  1416             Caller.getFieldTargetNotOurHost();
  1416             Caller.getFieldTargetNotOurHost();
  1417             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1417             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1418         }
  1418         }
  1419         catch (IncompatibleClassChangeError expected) {
  1419         catch (IncompatibleClassChangeError expected) {
  1432         }
  1432         }
  1433         catch (IncompatibleClassChangeError expected) {
  1433         catch (IncompatibleClassChangeError expected) {
  1434             check_expected(expected, msg);
  1434             check_expected(expected, msg);
  1435         }
  1435         }
  1436 
  1436 
  1437         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
  1437         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
  1438             " of InvalidNestHost: current type is not listed as a nest member";
  1438             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1439         try {
  1439         try {
  1440             CallerNotOurHost.getFieldTarget();
  1440             CallerNotOurHost.getFieldTarget();
  1441             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1441             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1442         }
  1442         }
  1443         catch (IncompatibleClassChangeError expected) {
  1443         catch (IncompatibleClassChangeError expected) {
  1444             check_expected(expected, msg);
  1444             check_expected(expected, msg);
  1445         }
  1445         }
  1446         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
  1446         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
  1447             " of InvalidNestHost: current type is not listed as a nest member";
  1447             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1448         try {
  1448         try {
  1449             CallerNotOurHost.getFieldTargetNotOurHost();
  1449             CallerNotOurHost.getFieldTargetNotOurHost();
  1450             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1450             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1451         }
  1451         }
  1452         catch (IncompatibleClassChangeError expected) {
  1452         catch (IncompatibleClassChangeError expected) {
  1454         }
  1454         }
  1455     }
  1455     }
  1456 
  1456 
  1457     static void test_WrongPackageHostGetField() {
  1457     static void test_WrongPackageHostGetField() {
  1458         System.out.println("Testing for nest-host and nest-member in different packages");
  1458         System.out.println("Testing for nest-host and nest-member in different packages");
  1459         String msg = "Type P2.PackagedNestHost2$Member is not a nest member of " +
  1459         String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
  1460             "P1.PackagedNestHost: types are in different packages";
  1460             "P1.PackagedNestHost (loader: 'app'): types are in different packages";
  1461         try {
  1461         try {
  1462             P1.PackagedNestHost.doGetField();
  1462             P1.PackagedNestHost.doGetField();
  1463             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1463             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1464         }
  1464         }
  1465         catch (IncompatibleClassChangeError expected) {
  1465         catch (IncompatibleClassChangeError expected) {
  1532         }
  1532         }
  1533     }
  1533     }
  1534 
  1534 
  1535     static void test_SelfHostPutField() throws Throwable {
  1535     static void test_SelfHostPutField() throws Throwable {
  1536         System.out.println("Testing for class that lists itself as nest-host");
  1536         System.out.println("Testing for class that lists itself as nest-host");
  1537         String msg = "Type TestNestmateMembership$TargetSelfHost is not a nest member" +
  1537         String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
  1538             " of TestNestmateMembership$TargetSelfHost: current type is not listed as a nest member";
  1538             " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
  1539         try {
  1539         try {
  1540             Caller.putFieldTargetSelfHost();
  1540             Caller.putFieldTargetSelfHost();
  1541             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1541             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1542         }
  1542         }
  1543         catch (IncompatibleClassChangeError expected) {
  1543         catch (IncompatibleClassChangeError expected) {
  1556         }
  1556         }
  1557         catch (IncompatibleClassChangeError expected) {
  1557         catch (IncompatibleClassChangeError expected) {
  1558             check_expected(expected, msg);
  1558             check_expected(expected, msg);
  1559         }
  1559         }
  1560 
  1560 
  1561         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
  1561         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
  1562             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
  1562             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
  1563         try {
  1563         try {
  1564             CallerSelfHost.putFieldTarget();
  1564             CallerSelfHost.putFieldTarget();
  1565             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1565             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1566         }
  1566         }
  1567         catch (IncompatibleClassChangeError expected) {
  1567         catch (IncompatibleClassChangeError expected) {
  1568             check_expected(expected, msg);
  1568             check_expected(expected, msg);
  1569         }
  1569         }
  1570         msg = "Type TestNestmateMembership$CallerSelfHost is not a nest member" +
  1570         msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
  1571             " of TestNestmateMembership$CallerSelfHost: current type is not listed as a nest member";
  1571             " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
  1572         try {
  1572         try {
  1573             CallerSelfHost.putFieldTargetSelfHost();
  1573             CallerSelfHost.putFieldTargetSelfHost();
  1574             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1574             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1575         }
  1575         }
  1576         catch (IncompatibleClassChangeError expected) {
  1576         catch (IncompatibleClassChangeError expected) {
  1627         }
  1627         }
  1628     }
  1628     }
  1629 
  1629 
  1630     static void test_NotInstanceHostPutField() throws Throwable {
  1630     static void test_NotInstanceHostPutField() throws Throwable {
  1631         System.out.println("Testing for nest-host class that is not an instance class");
  1631         System.out.println("Testing for nest-host class that is not an instance class");
  1632         String msg = "Type TestNestmateMembership$TargetNotInstanceHost is not a "+
  1632         String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
  1633             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1633             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1634         try {
  1634         try {
  1635             Caller.putFieldTargetNotInstanceHost();
  1635             Caller.putFieldTargetNotInstanceHost();
  1636             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1636             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1637         }
  1637         }
  1638         catch (IncompatibleClassChangeError expected) {
  1638         catch (IncompatibleClassChangeError expected) {
  1651         }
  1651         }
  1652         catch (IncompatibleClassChangeError expected) {
  1652         catch (IncompatibleClassChangeError expected) {
  1653             check_expected(expected, msg);
  1653             check_expected(expected, msg);
  1654         }
  1654         }
  1655 
  1655 
  1656         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
  1656         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
  1657             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1657             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1658         try {
  1658         try {
  1659             CallerNotInstanceHost.putFieldTarget();
  1659             CallerNotInstanceHost.putFieldTarget();
  1660             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1660             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1661         }
  1661         }
  1662         catch (IncompatibleClassChangeError expected) {
  1662         catch (IncompatibleClassChangeError expected) {
  1663             check_expected(expected, msg);
  1663             check_expected(expected, msg);
  1664         }
  1664         }
  1665         msg = "Type TestNestmateMembership$CallerNotInstanceHost is not a "+
  1665         msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
  1666             "nest member of [LInvalidNestHost;: current type is not listed as a nest member";
  1666             "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
  1667         try {
  1667         try {
  1668             CallerNotInstanceHost.putFieldTargetNotInstanceHost();
  1668             CallerNotInstanceHost.putFieldTargetNotInstanceHost();
  1669             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1669             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1670         }
  1670         }
  1671         catch (IncompatibleClassChangeError expected) {
  1671         catch (IncompatibleClassChangeError expected) {
  1673         }
  1673         }
  1674     }
  1674     }
  1675 
  1675 
  1676     static void test_NotOurHostPutField() throws Throwable {
  1676     static void test_NotOurHostPutField() throws Throwable {
  1677         System.out.println("Testing for nest-host class that does not list us in its nest");
  1677         System.out.println("Testing for nest-host class that does not list us in its nest");
  1678         String msg = "Type TestNestmateMembership$TargetNotOurHost is not a nest member" +
  1678         String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
  1679             " of InvalidNestHost: current type is not listed as a nest member";
  1679             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1680         try {
  1680         try {
  1681             Caller.putFieldTargetNotOurHost();
  1681             Caller.putFieldTargetNotOurHost();
  1682             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1682             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1683         }
  1683         }
  1684         catch (IncompatibleClassChangeError expected) {
  1684         catch (IncompatibleClassChangeError expected) {
  1697         }
  1697         }
  1698         catch (IncompatibleClassChangeError expected) {
  1698         catch (IncompatibleClassChangeError expected) {
  1699             check_expected(expected, msg);
  1699             check_expected(expected, msg);
  1700         }
  1700         }
  1701 
  1701 
  1702         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
  1702         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
  1703             " of InvalidNestHost: current type is not listed as a nest member";
  1703             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1704         try {
  1704         try {
  1705             CallerNotOurHost.putFieldTarget();
  1705             CallerNotOurHost.putFieldTarget();
  1706             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1706             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1707         }
  1707         }
  1708         catch (IncompatibleClassChangeError expected) {
  1708         catch (IncompatibleClassChangeError expected) {
  1709             check_expected(expected, msg);
  1709             check_expected(expected, msg);
  1710         }
  1710         }
  1711         msg = "Type TestNestmateMembership$CallerNotOurHost is not a nest member" +
  1711         msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
  1712             " of InvalidNestHost: current type is not listed as a nest member";
  1712             " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
  1713         try {
  1713         try {
  1714             CallerNotOurHost.putFieldTargetNotOurHost();
  1714             CallerNotOurHost.putFieldTargetNotOurHost();
  1715             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1715             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1716         }
  1716         }
  1717         catch (IncompatibleClassChangeError expected) {
  1717         catch (IncompatibleClassChangeError expected) {
  1719         }
  1719         }
  1720     }
  1720     }
  1721 
  1721 
  1722     static void test_WrongPackageHostPutField() {
  1722     static void test_WrongPackageHostPutField() {
  1723         System.out.println("Testing for nest-host and nest-member in different packages");
  1723         System.out.println("Testing for nest-host and nest-member in different packages");
  1724         String msg = "Type P2.PackagedNestHost2$Member is not a nest member of " +
  1724         String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
  1725             "P1.PackagedNestHost: types are in different packages";
  1725             "P1.PackagedNestHost (loader: 'app'): types are in different packages";
  1726         try {
  1726         try {
  1727             P1.PackagedNestHost.doPutField();
  1727             P1.PackagedNestHost.doPutField();
  1728             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1728             throw new Error("Missing IncompatibleClassChangeError: " + msg);
  1729         }
  1729         }
  1730         catch (IncompatibleClassChangeError expected) {
  1730         catch (IncompatibleClassChangeError expected) {