1 /*
2 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
680 check_expected(expected, msg);
681 }
682 msg = "TestNestmateMembership$Caller cannot access a member of class " +
683 "TestNestmateMembership$TargetNoHost with modifiers \"private static\"";
684 try {
685 Caller.invokeTargetNoHostReflectively();
686 throw new Error("Missing IllegalAccessException: " + msg);
687 }
688 catch (IllegalAccessException expected) {
689 check_expected(expected, msg);
690 }
691 msg = "no such method: TestNestmateMembership$TargetNoHost.m()void/invokeStatic";
692 try {
693 Caller.invokeTargetNoHostMH();
694 throw new Error("Missing IllegalAccessException: " + msg);
695 }
696 catch (IllegalAccessException expected) {
697 check_expected(expected, msg);
698 }
699
700 msg = "class TestNestmateMembership$CallerNoHost tried to access " +
701 "private method 'void TestNestmateMembership$Target.m()'";
702 try {
703 CallerNoHost.invokeTarget();
704 throw new Error("Missing IllegalAccessError: " + msg);
705 }
706 catch (IllegalAccessError expected) {
707 check_expected(expected, msg);
708 }
709 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
710 "method 'void TestNestmateMembership$TargetNoHost.m()'";
711 try {
712 CallerNoHost.invokeTargetNoHost();
713 throw new Error("Missing IllegalAccessError: " + msg);
714 }
715 catch (IllegalAccessError expected) {
716 check_expected(expected, msg);
717 }
718 }
719
720 static void test_SelfHostInvoke() throws Throwable {
721 System.out.println("Testing for class that lists itself as nest-host");
722 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
723 " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
724 try {
725 Caller.invokeTargetSelfHost();
726 throw new Error("Missing IncompatibleClassChangeError: " + msg);
727 }
728 catch (IncompatibleClassChangeError expected) {
729 check_expected(expected, msg);
730 }
731 try {
732 Caller.invokeTargetSelfHostReflectively();
733 throw new Error("Missing IncompatibleClassChangeError: " + msg);
734 }
735 catch (IncompatibleClassChangeError expected) {
736 check_expected(expected, msg);
737 }
738 msg = "no such method: TestNestmateMembership$TargetSelfHost.m()void/invokeStatic";
739 try {
740 Caller.invokeTargetSelfHostMH();
741 throw new Error("Missing IllegalAccessException: " + msg);
742 }
743 catch (IllegalAccessException expected) {
744 check_expected(expected, msg);
745 }
746
747 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
748 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
749 try {
750 CallerSelfHost.invokeTarget();
751 throw new Error("Missing IncompatibleClassChangeError: " + msg);
752 }
753 catch (IncompatibleClassChangeError expected) {
754 check_expected(expected, msg);
755 }
756 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
757 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
758 try {
759 CallerSelfHost.invokeTargetSelfHost();
760 throw new Error("Missing IncompatibleClassChangeError: " + msg);
761 }
762 catch (IncompatibleClassChangeError expected) {
763 check_expected(expected, msg);
764 }
765 }
766
767 static void test_MissingHostInvoke() throws Throwable {
768 System.out.println("Testing for nest-host class that does not exist");
769 String msg = "Unable to load nest-host class (NoTargetMissingHost) of " +
770 "TestNestmateMembership$TargetMissingHost";
771 String cause_msg = "NoTargetMissingHost";
772 try {
773 Caller.invokeTargetMissingHost();
774 throw new Error("Missing NoClassDefFoundError: " + msg);
775 }
776 catch (NoClassDefFoundError expected) {
777 check_expected(expected, msg, cause_msg);
778 }
779 try {
780 Caller.invokeTargetMissingHostReflectively();
781 throw new Error("Missing NoClassDefFoundError: " + msg);
782 }
783 catch (NoClassDefFoundError expected) {
784 check_expected(expected, msg, cause_msg);
785 }
786 msg = "no such method: TestNestmateMembership$TargetMissingHost.m()void/invokeStatic";
787 try {
788 Caller.invokeTargetMissingHostMH();
789 throw new Error("Missing IllegalAccessException: " + msg);
790 }
791 catch (IllegalAccessException expected) {
792 check_expected(expected, msg);
793 }
794 msg = "no such method: TestNestmateMembership$TargetMissingHost.m()void/invokeStatic";
795 try {
796 Caller.invokeTargetMissingHostMH();
797 throw new Error("Missing IllegalAccessException: " + msg);
798 }
799 catch (IllegalAccessException expected) {
800 check_expected(expected, msg);
801 }
802
803 msg = "Unable to load nest-host class (NoCallerMissingHost) of " +
804 "TestNestmateMembership$CallerMissingHost";
805 cause_msg = "NoCallerMissingHost";
806 try {
807 CallerMissingHost.invokeTarget();
808 throw new Error("Missing NoClassDefFoundError: " + msg);
809 }
810 catch (NoClassDefFoundError expected) {
811 check_expected(expected, msg, cause_msg);
812 }
813 msg = "Unable to load nest-host class (NoCallerMissingHost) of "+
814 "TestNestmateMembership$CallerMissingHost";
815 cause_msg = "NoCallerMissingHost";
816 try {
817 CallerMissingHost.invokeTargetMissingHost();
818 throw new Error("Missing NoClassDefFoundError: " + msg);
819 }
820 catch (NoClassDefFoundError expected) {
821 check_expected(expected, msg, cause_msg);
822 }
823 }
824
825 static void test_NotInstanceHostInvoke() throws Throwable {
826 System.out.println("Testing for nest-host class that is not an instance class");
827 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
828 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
829 try {
830 Caller.invokeTargetNotInstanceHost();
831 throw new Error("Missing IncompatibleClassChangeError: " + msg);
832 }
833 catch (IncompatibleClassChangeError expected) {
834 check_expected(expected, msg);
835 }
836 try {
837 Caller.invokeTargetNotInstanceHostReflectively();
838 throw new Error("Missing IncompatibleClassChangeError: " + msg);
839 }
840 catch (IncompatibleClassChangeError expected) {
841 check_expected(expected, msg);
842 }
843 msg = "no such method: TestNestmateMembership$TargetNotInstanceHost.m()void/invokeStatic";
844 try {
845 Caller.invokeTargetNotInstanceHostMH();
846 throw new Error("Missing IllegalAccessException: " + msg);
847 }
848 catch (IllegalAccessException expected) {
849 check_expected(expected, msg);
850 }
851
852 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
853 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
854 try {
855 CallerNotInstanceHost.invokeTarget();
856 throw new Error("Missing IncompatibleClassChangeError: " + msg);
857 }
858 catch (IncompatibleClassChangeError expected) {
859 check_expected(expected, msg);
860 }
861 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
862 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
863 try {
864 CallerNotInstanceHost.invokeTargetNotInstanceHost();
865 throw new Error("Missing IncompatibleClassChangeError: " + msg);
866 }
867 catch (IncompatibleClassChangeError expected) {
868 check_expected(expected, msg);
869 }
870 }
871
872 static void test_NotOurHostInvoke() throws Throwable {
873 System.out.println("Testing for nest-host class that does not list us in its nest");
874 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
875 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
876 try {
877 Caller.invokeTargetNotOurHost();
878 throw new Error("Missing IncompatibleClassChangeError: " + msg);
879 }
880 catch (IncompatibleClassChangeError expected) {
881 check_expected(expected, msg);
882 }
883 try {
884 Caller.invokeTargetNotOurHostReflectively();
885 throw new Error("Missing IncompatibleClassChangeError: " + msg);
886 }
887 catch (IncompatibleClassChangeError expected) {
888 check_expected(expected, msg);
889 }
890 msg = "no such method: TestNestmateMembership$TargetNotOurHost.m()void/invokeStatic";
891 try {
892 Caller.invokeTargetNotOurHostMH();
893 throw new Error("Missing IllegalAccessException: " + msg);
894 }
895 catch (IllegalAccessException expected) {
896 check_expected(expected, msg);
897 }
898
899 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
900 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
901 try {
902 CallerNotOurHost.invokeTarget();
903 throw new Error("Missing IncompatibleClassChangeError: " + msg);
904 }
905 catch (IncompatibleClassChangeError expected) {
906 check_expected(expected, msg);
907 }
908 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
909 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
910 try {
911 CallerNotOurHost.invokeTargetNotOurHost();
912 throw new Error("Missing IncompatibleClassChangeError: " + msg);
913 }
914 catch (IncompatibleClassChangeError expected) {
915 check_expected(expected, msg);
916 }
917 }
918
919 static void test_WrongPackageHostInvoke() {
920 System.out.println("Testing for nest-host and nest-member in different packages");
921 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
922 "P1.PackagedNestHost (loader: 'app'): types are in different packages";
923 try {
924 P1.PackagedNestHost.doInvoke();
925 throw new Error("Missing IncompatibleClassChangeError: " + msg);
926 }
927 catch (IncompatibleClassChangeError expected) {
928 check_expected(expected, msg);
929 }
930 try {
931 P2.PackagedNestHost2.Member.doInvoke();
932 throw new Error("Missing IncompatibleClassChangeError: " + msg);
933 }
934 catch (IncompatibleClassChangeError expected) {
935 check_expected(expected, msg);
936 }
937 }
938
939 // constructor tests
940
941 static void test_GoodConstruct(){
942 try {
943 Caller.newTarget();
944 }
945 catch (Exception e) {
946 throw new Error("Unexpected exception on good construction: " + e);
947 }
948 }
949
950 static void test_NoHostConstruct() throws Throwable {
951 System.out.println("Testing for missing nest-host attribute");
952 String msg = "class TestNestmateMembership$Caller tried to access private " +
953 "method 'void TestNestmateMembership$TargetNoHost.<init>()'";
954 try {
955 Caller.newTargetNoHost();
956 throw new Error("Missing IncompatibleClassChangeError: " + msg);
957 }
958 catch (IncompatibleClassChangeError expected) {
959 check_expected(expected, msg);
960 }
961 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
962 "TestNestmateMembership$TargetNoHost with modifiers \"private\"";
963 try {
964 Caller.newTargetNoHostReflectively();
965 throw new Error("Missing IllegalAccessException: " + msg);
966 }
967 catch (IllegalAccessException expected) {
968 check_expected(expected, msg);
969 }
970 msg = "no such constructor: TestNestmateMembership$TargetNoHost.<init>()void/newInvokeSpecial";
971 try {
972 Caller.newTargetNoHostMH();
973 throw new Error("Missing IllegalAccessException: " + msg);
974 }
975 catch (IllegalAccessException expected) {
976 check_expected(expected, msg);
977 }
978
979 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
980 "method 'void TestNestmateMembership$Target.<init>()'";
981 try {
982 CallerNoHost.newTarget();
983 throw new Error("Missing IncompatibleClassChangeError: " + msg);
984 }
985 catch (IncompatibleClassChangeError expected) {
986 check_expected(expected, msg);
987 }
988 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
989 "method 'void TestNestmateMembership$TargetNoHost.<init>()'";
990 try {
991 CallerNoHost.newTargetNoHost();
992 throw new Error("Missing IncompatibleClassChangeError: " + msg);
993 }
994 catch (IncompatibleClassChangeError expected) {
995 check_expected(expected, msg);
996 }
997 }
998
999 static void test_SelfHostConstruct() throws Throwable {
1000 System.out.println("Testing for class that lists itself as nest-host");
1001 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
1002 " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
1003 try {
1004 Caller.newTargetSelfHost();
1005 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1006 }
1007 catch (IncompatibleClassChangeError expected) {
1008 check_expected(expected, msg);
1009 }
1010 try {
1011 Caller.newTargetSelfHostReflectively();
1012 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1013 }
1014 catch (IncompatibleClassChangeError expected) {
1015 check_expected(expected, msg);
1016 }
1017 msg = "no such constructor: TestNestmateMembership$TargetSelfHost.<init>()void/newInvokeSpecial";
1018 try {
1019 Caller.newTargetSelfHostMH();
1020 throw new Error("Missing IllegalAccessException: " + msg);
1021 }
1022 catch (IllegalAccessException expected) {
1023 check_expected(expected, msg);
1024 }
1025
1026 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1027 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1028 try {
1029 CallerSelfHost.newTarget();
1030 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1031 }
1032 catch (IncompatibleClassChangeError expected) {
1033 check_expected(expected, msg);
1034 }
1035 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1036 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1037 try {
1038 CallerSelfHost.newTargetSelfHost();
1039 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1040 }
1041 catch (IncompatibleClassChangeError expected) {
1042 check_expected(expected, msg);
1043 }
1044 }
1045
1046 static void test_MissingHostConstruct() throws Throwable {
1047 System.out.println("Testing for nest-host class that does not exist");
1048 String msg = "Unable to load nest-host class (NoTargetMissingHost) of " +
1049 "TestNestmateMembership$TargetMissingHost";
1050 String cause_msg = "NoTargetMissingHost";
1051 try {
1052 Caller.newTargetMissingHost();
1053 throw new Error("Missing NoClassDefFoundError: " + msg);
1054 }
1055 catch (NoClassDefFoundError expected) {
1056 check_expected(expected, msg, cause_msg);
1057 }
1058 try {
1059 Caller.newTargetMissingHostReflectively();
1060 throw new Error("Missing NoClassDefFoundError: " + msg);
1061 }
1062 catch (NoClassDefFoundError expected) {
1063 check_expected(expected, msg, cause_msg);
1064 }
1065 msg = "no such constructor: TestNestmateMembership$TargetMissingHost.<init>()void/newInvokeSpecial";
1066 try {
1067 Caller.newTargetMissingHostMH();
1068 throw new Error("Missing IllegalAccessException: " + msg);
1069 }
1070 catch (IllegalAccessException expected) {
1071 check_expected(expected, msg);
1072 }
1073
1074 msg = "Unable to load nest-host class (NoCallerMissingHost) of " +
1075 "TestNestmateMembership$CallerMissingHost";
1076 cause_msg = "NoCallerMissingHost";
1077 try {
1078 CallerMissingHost.newTarget();
1079 throw new Error("Missing NoClassDefFoundError: " + msg);
1080 }
1081 catch (NoClassDefFoundError expected) {
1082 check_expected(expected, msg, cause_msg);
1083 }
1084 msg = "Unable to load nest-host class (NoCallerMissingHost) of "+
1085 "TestNestmateMembership$CallerMissingHost";
1086 cause_msg = "NoCallerMissingHost";
1087 try {
1088 CallerMissingHost.newTargetMissingHost();
1089 throw new Error("Missing NoClassDefFoundError: " + msg);
1090 }
1091 catch (NoClassDefFoundError expected) {
1092 check_expected(expected, msg, cause_msg);
1093 }
1094 }
1095
1096 static void test_NotInstanceHostConstruct() throws Throwable {
1097 System.out.println("Testing for nest-host class that is not an instance class");
1098 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
1099 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1100 try {
1101 Caller.newTargetNotInstanceHost();
1102 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1103 }
1104 catch (IncompatibleClassChangeError expected) {
1105 check_expected(expected, msg);
1106 }
1107 try {
1108 Caller.newTargetNotInstanceHostReflectively();
1109 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1110 }
1111 catch (IncompatibleClassChangeError expected) {
1112 check_expected(expected, msg);
1113 }
1114 msg = "no such constructor: TestNestmateMembership$TargetNotInstanceHost.<init>()void/newInvokeSpecial";
1115 try {
1116 Caller.newTargetNotInstanceHostMH();
1117 throw new Error("Missing IllegalAccessException: " + msg);
1118 }
1119 catch (IllegalAccessException expected) {
1120 check_expected(expected, msg);
1121 }
1122
1123 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1124 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1125 try {
1126 CallerNotInstanceHost.newTarget();
1127 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1128 }
1129 catch (IncompatibleClassChangeError expected) {
1130 check_expected(expected, msg);
1131 }
1132 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1133 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1134 try {
1135 CallerNotInstanceHost.newTargetNotInstanceHost();
1136 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1137 }
1138 catch (IncompatibleClassChangeError expected) {
1139 check_expected(expected, msg);
1140 }
1141 }
1142
1143 static void test_NotOurHostConstruct() throws Throwable {
1144 System.out.println("Testing for nest-host class that does not list us in its nest");
1145 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
1146 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1147 try {
1148 Caller.newTargetNotOurHost();
1149 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1150 }
1151 catch (IncompatibleClassChangeError expected) {
1152 check_expected(expected, msg);
1153 }
1154 try {
1155 Caller.newTargetNotOurHostReflectively();
1156 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1157 }
1158 catch (IncompatibleClassChangeError expected) {
1159 check_expected(expected, msg);
1160 }
1161 msg = "no such constructor: TestNestmateMembership$TargetNotOurHost.<init>()void/newInvokeSpecial";
1162 try {
1163 Caller.newTargetNotOurHostMH();
1164 throw new Error("Missing IllegalAccessException: " + msg);
1165 }
1166 catch (IllegalAccessException expected) {
1167 check_expected(expected, msg);
1168 }
1169
1170 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1171 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1172 try {
1173 CallerNotOurHost.newTarget();
1174 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1175 }
1176 catch (IncompatibleClassChangeError expected) {
1177 check_expected(expected, msg);
1178 }
1179 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1180 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1181 try {
1182 CallerNotOurHost.newTargetNotOurHost();
1183 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1184 }
1185 catch (IncompatibleClassChangeError expected) {
1186 check_expected(expected, msg);
1187 }
1188 }
1189
1190 static void test_WrongPackageHostConstruct() {
1191 System.out.println("Testing for nest-host and nest-member in different packages");
1192 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
1193 "P1.PackagedNestHost (loader: 'app'): types are in different packages";
1194 try {
1195 P1.PackagedNestHost.doConstruct();
1196 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1197 }
1198 catch (IncompatibleClassChangeError expected) {
1199 check_expected(expected, msg);
1200 }
1201 try {
1202 P2.PackagedNestHost2.Member.doConstruct();
1203 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1204 }
1205 catch (IncompatibleClassChangeError expected) {
1206 check_expected(expected, msg);
1207 }
1208 }
1209
1210 // field tests
1211
1212 static void test_GoodGetField(){
1213 try {
1214 Caller.getFieldTarget();
1215 }
1216 catch (Exception e) {
1217 throw new Error("Unexpected exception on good field access: " + e);
1218 }
1219 }
1220
1221 static void test_NoHostGetField() throws Throwable {
1222 System.out.println("Testing for missing nest-host attribute");
1223 String msg = "class TestNestmateMembership$Caller tried to access private " +
1224 "field TestNestmateMembership$TargetNoHost.f";
1225 try {
1226 Caller.getFieldTargetNoHost();
1227 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1228 }
1229 catch (IncompatibleClassChangeError expected) {
1230 check_expected(expected, msg);
1231 }
1232 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1233 "TestNestmateMembership$TargetNoHost with modifiers \"private static\"";
1234 try {
1235 Caller.getFieldTargetNoHostReflectively();
1236 throw new Error("Missing IllegalAccessException: " + msg);
1237 }
1238 catch (IllegalAccessException expected) {
1239 check_expected(expected, msg);
1240 }
1241 msg = "member is private: TestNestmateMembership$TargetNoHost.f/int/getStatic";
1242 try {
1243 Caller.getFieldTargetNoHostMH();
1244 throw new Error("Missing IllegalAccessException: " + msg);
1245 }
1246 catch (IllegalAccessException expected) {
1247 check_expected(expected, msg);
1248 }
1249
1250 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1251 "field TestNestmateMembership$Target.f";
1252 try {
1253 CallerNoHost.getFieldTarget();
1254 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1255 }
1256 catch (IncompatibleClassChangeError expected) {
1257 check_expected(expected, msg);
1258 }
1259 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1260 "field TestNestmateMembership$TargetNoHost.f";
1261 try {
1262 CallerNoHost.getFieldTargetNoHost();
1263 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1264 }
1265 catch (IncompatibleClassChangeError expected) {
1266 check_expected(expected, msg);
1267 }
1268 }
1269
1270 static void test_SelfHostGetField() throws Throwable {
1271 System.out.println("Testing for class that lists itself as nest-host");
1272 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
1273 " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
1274 try {
1275 Caller.getFieldTargetSelfHost();
1276 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1277 }
1278 catch (IncompatibleClassChangeError expected) {
1279 check_expected(expected, msg);
1280 }
1281 try {
1282 Caller.getFieldTargetSelfHostReflectively();
1283 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1284 }
1285 catch (IncompatibleClassChangeError expected) {
1286 check_expected(expected, msg);
1287 }
1288 try {
1289 Caller.getFieldTargetSelfHostMH();
1290 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1291 }
1292 catch (IncompatibleClassChangeError expected) {
1293 check_expected(expected, msg);
1294 }
1295
1296 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1297 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1298 try {
1299 CallerSelfHost.getFieldTarget();
1300 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1301 }
1302 catch (IncompatibleClassChangeError expected) {
1303 check_expected(expected, msg);
1304 }
1305 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1306 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1307 try {
1308 CallerSelfHost.getFieldTargetSelfHost();
1309 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1310 }
1311 catch (IncompatibleClassChangeError expected) {
1312 check_expected(expected, msg);
1313 }
1314 }
1315
1316 static void test_MissingHostGetField() throws Throwable {
1317 System.out.println("Testing for nest-host class that does not exist");
1318 String msg = "Unable to load nest-host class (NoTargetMissingHost) of " +
1319 "TestNestmateMembership$TargetMissingHost";
1320 String cause_msg = "NoTargetMissingHost";
1321 try {
1322 Caller.getFieldTargetMissingHost();
1323 throw new Error("Missing NoClassDefFoundError: " + msg);
1324 }
1325 catch (NoClassDefFoundError expected) {
1326 check_expected(expected, msg, cause_msg);
1327 }
1328 try {
1329 Caller.getFieldTargetMissingHostReflectively();
1330 throw new Error("Missing NoClassDefFoundError: " + msg);
1331 }
1332 catch (NoClassDefFoundError expected) {
1333 check_expected(expected, msg, cause_msg);
1334 }
1335 try {
1336 Caller.getFieldTargetMissingHostMH();
1337 throw new Error("Missing NoClassDefFoundError: " + msg);
1338 }
1339 catch (NoClassDefFoundError expected) {
1340 check_expected(expected, msg, cause_msg);
1341 }
1342
1343 msg = "Unable to load nest-host class (NoCallerMissingHost) of " +
1344 "TestNestmateMembership$CallerMissingHost";
1345 cause_msg = "NoCallerMissingHost";
1346 try {
1347 CallerMissingHost.getFieldTarget();
1348 throw new Error("Missing NoClassDefFoundError: " + msg);
1349 }
1350 catch (NoClassDefFoundError expected) {
1351 check_expected(expected, msg, cause_msg);
1352 }
1353 msg = "Unable to load nest-host class (NoCallerMissingHost) of "+
1354 "TestNestmateMembership$CallerMissingHost";
1355 cause_msg = "NoCallerMissingHost";
1356 try {
1357 CallerMissingHost.getFieldTargetMissingHost();
1358 throw new Error("Missing NoClassDefFoundError: " + msg);
1359 }
1360 catch (NoClassDefFoundError expected) {
1361 check_expected(expected, msg, cause_msg);
1362 }
1363 }
1364
1365 static void test_NotInstanceHostGetField() throws Throwable {
1366 System.out.println("Testing for nest-host class that is not an instance class");
1367 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
1368 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1369 try {
1370 Caller.getFieldTargetNotInstanceHost();
1371 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1372 }
1373 catch (IncompatibleClassChangeError expected) {
1374 check_expected(expected, msg);
1375 }
1376 try {
1377 Caller.getFieldTargetNotInstanceHostReflectively();
1378 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1379 }
1380 catch (IncompatibleClassChangeError expected) {
1381 check_expected(expected, msg);
1382 }
1383 try {
1384 Caller.getFieldTargetNotInstanceHostMH();
1385 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1386 }
1387 catch (IncompatibleClassChangeError expected) {
1388 check_expected(expected, msg);
1389 }
1390
1391 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1392 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1393 try {
1394 CallerNotInstanceHost.getFieldTarget();
1395 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1396 }
1397 catch (IncompatibleClassChangeError expected) {
1398 check_expected(expected, msg);
1399 }
1400 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1401 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1402 try {
1403 CallerNotInstanceHost.getFieldTargetNotInstanceHost();
1404 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1405 }
1406 catch (IncompatibleClassChangeError expected) {
1407 check_expected(expected, msg);
1408 }
1409 }
1410
1411 static void test_NotOurHostGetField() throws Throwable {
1412 System.out.println("Testing for nest-host class that does not list us in its nest");
1413 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
1414 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1415 try {
1416 Caller.getFieldTargetNotOurHost();
1417 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1418 }
1419 catch (IncompatibleClassChangeError expected) {
1420 check_expected(expected, msg);
1421 }
1422 try {
1423 Caller.getFieldTargetNotOurHostReflectively();
1424 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1425 }
1426 catch (IncompatibleClassChangeError expected) {
1427 check_expected(expected, msg);
1428 }
1429 try {
1430 Caller.getFieldTargetNotOurHostMH();
1431 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1432 }
1433 catch (IncompatibleClassChangeError expected) {
1434 check_expected(expected, msg);
1435 }
1436
1437 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1438 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1439 try {
1440 CallerNotOurHost.getFieldTarget();
1441 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1442 }
1443 catch (IncompatibleClassChangeError expected) {
1444 check_expected(expected, msg);
1445 }
1446 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1447 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1448 try {
1449 CallerNotOurHost.getFieldTargetNotOurHost();
1450 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1451 }
1452 catch (IncompatibleClassChangeError expected) {
1453 check_expected(expected, msg);
1454 }
1455 }
1456
1457 static void test_WrongPackageHostGetField() {
1458 System.out.println("Testing for nest-host and nest-member in different packages");
1459 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
1460 "P1.PackagedNestHost (loader: 'app'): types are in different packages";
1461 try {
1462 P1.PackagedNestHost.doGetField();
1463 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1464 }
1465 catch (IncompatibleClassChangeError expected) {
1466 check_expected(expected, msg);
1467 }
1468 try {
1469 P2.PackagedNestHost2.Member.doGetField();
1470 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1471 }
1472 catch (IncompatibleClassChangeError expected) {
1473 check_expected(expected, msg);
1474 }
1475 }
1476
1477 static void test_GoodPutField(){
1478 try {
1479 Caller.putFieldTarget();
1480 }
1481 catch (Exception e) {
1482 throw new Error("Unexpected exception on good field access: " + e);
1483 }
1484 }
1485
1486 static void test_NoHostPutField() throws Throwable {
1487 System.out.println("Testing for missing nest-host attribute");
1488 String msg = "class TestNestmateMembership$Caller tried to access private " +
1489 "field TestNestmateMembership$TargetNoHost.f";
1490 try {
1491 Caller.putFieldTargetNoHost();
1492 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1493 }
1494 catch (IncompatibleClassChangeError expected) {
1495 check_expected(expected, msg);
1496 }
1497 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1498 "TestNestmateMembership$TargetNoHost with modifiers \"private static\"";
1499 try {
1500 Caller.putFieldTargetNoHostReflectively();
1501 throw new Error("Missing IllegalAccessException: " + msg);
1502 }
1503 catch (IllegalAccessException expected) {
1504 check_expected(expected, msg);
1505 }
1506 msg = "member is private: TestNestmateMembership$TargetNoHost.f/int/putStatic";
1507 try {
1508 Caller.putFieldTargetNoHostMH();
1509 throw new Error("Missing IllegalAccessException: " + msg);
1510 }
1511 catch (IllegalAccessException expected) {
1512 check_expected(expected, msg);
1513 }
1514
1515 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1516 "field TestNestmateMembership$Target.f";
1517 try {
1518 CallerNoHost.putFieldTarget();
1519 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1520 }
1521 catch (IncompatibleClassChangeError expected) {
1522 check_expected(expected, msg);
1523 }
1524 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1525 "field TestNestmateMembership$TargetNoHost.f";
1526 try {
1527 CallerNoHost.putFieldTargetNoHost();
1528 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1529 }
1530 catch (IncompatibleClassChangeError expected) {
1531 check_expected(expected, msg);
1532 }
1533 }
1534
1535 static void test_SelfHostPutField() throws Throwable {
1536 System.out.println("Testing for class that lists itself as nest-host");
1537 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
1538 " of TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
1539 try {
1540 Caller.putFieldTargetSelfHost();
1541 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1542 }
1543 catch (IncompatibleClassChangeError expected) {
1544 check_expected(expected, msg);
1545 }
1546 try {
1547 Caller.putFieldTargetSelfHostReflectively();
1548 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1549 }
1550 catch (IncompatibleClassChangeError expected) {
1551 check_expected(expected, msg);
1552 }
1553 try {
1554 Caller.putFieldTargetSelfHostMH();
1555 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1556 }
1557 catch (IncompatibleClassChangeError expected) {
1558 check_expected(expected, msg);
1559 }
1560
1561 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1562 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1563 try {
1564 CallerSelfHost.putFieldTarget();
1565 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1566 }
1567 catch (IncompatibleClassChangeError expected) {
1568 check_expected(expected, msg);
1569 }
1570 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1571 " of TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1572 try {
1573 CallerSelfHost.putFieldTargetSelfHost();
1574 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1575 }
1576 catch (IncompatibleClassChangeError expected) {
1577 check_expected(expected, msg);
1578 }
1579 }
1580
1581 static void test_MissingHostPutField() throws Throwable {
1582 System.out.println("Testing for nest-host class that does not exist");
1583 String msg = "Unable to load nest-host class (NoTargetMissingHost) of " +
1584 "TestNestmateMembership$TargetMissingHost";
1585 String cause_msg = "NoTargetMissingHost";
1586 try {
1587 Caller.putFieldTargetMissingHost();
1588 throw new Error("Missing NoClassDefFoundError: " + msg);
1589 }
1590 catch (NoClassDefFoundError expected) {
1591 check_expected(expected, msg, cause_msg);
1592 }
1593 try {
1594 Caller.putFieldTargetMissingHostReflectively();
1595 throw new Error("Missing NoClassDefFoundError: " + msg);
1596 }
1597 catch (NoClassDefFoundError expected) {
1598 check_expected(expected, msg, cause_msg);
1599 }
1600 try {
1601 Caller.putFieldTargetMissingHostMH();
1602 throw new Error("Missing NoClassDefFoundError: " + msg);
1603 }
1604 catch (NoClassDefFoundError expected) {
1605 check_expected(expected, msg, cause_msg);
1606 }
1607
1608 msg = "Unable to load nest-host class (NoCallerMissingHost) of " +
1609 "TestNestmateMembership$CallerMissingHost";
1610 cause_msg = "NoCallerMissingHost";
1611 try {
1612 CallerMissingHost.putFieldTarget();
1613 throw new Error("Missing NoClassDefFoundError: " + msg);
1614 }
1615 catch (NoClassDefFoundError expected) {
1616 check_expected(expected, msg, cause_msg);
1617 }
1618 msg = "Unable to load nest-host class (NoCallerMissingHost) of "+
1619 "TestNestmateMembership$CallerMissingHost";
1620 cause_msg = "NoCallerMissingHost";
1621 try {
1622 CallerMissingHost.putFieldTargetMissingHost();
1623 throw new Error("Missing NoClassDefFoundError: " + msg);
1624 }
1625 catch (NoClassDefFoundError expected) {
1626 check_expected(expected, msg, cause_msg);
1627 }
1628 }
1629
1630 static void test_NotInstanceHostPutField() throws Throwable {
1631 System.out.println("Testing for nest-host class that is not an instance class");
1632 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
1633 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1634 try {
1635 Caller.putFieldTargetNotInstanceHost();
1636 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1637 }
1638 catch (IncompatibleClassChangeError expected) {
1639 check_expected(expected, msg);
1640 }
1641 try {
1642 Caller.putFieldTargetNotInstanceHostReflectively();
1643 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1644 }
1645 catch (IncompatibleClassChangeError expected) {
1646 check_expected(expected, msg);
1647 }
1648 try {
1649 Caller.putFieldTargetNotInstanceHostMH();
1650 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1651 }
1652 catch (IncompatibleClassChangeError expected) {
1653 check_expected(expected, msg);
1654 }
1655
1656 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1657 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1658 try {
1659 CallerNotInstanceHost.putFieldTarget();
1660 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1661 }
1662 catch (IncompatibleClassChangeError expected) {
1663 check_expected(expected, msg);
1664 }
1665 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1666 "nest member of [LInvalidNestHost; (loader: 'app'): current type is not listed as a nest member";
1667 try {
1668 CallerNotInstanceHost.putFieldTargetNotInstanceHost();
1669 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1670 }
1671 catch (IncompatibleClassChangeError expected) {
1672 check_expected(expected, msg);
1673 }
1674 }
1675
1676 static void test_NotOurHostPutField() throws Throwable {
1677 System.out.println("Testing for nest-host class that does not list us in its nest");
1678 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
1679 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1680 try {
1681 Caller.putFieldTargetNotOurHost();
1682 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1683 }
1684 catch (IncompatibleClassChangeError expected) {
1685 check_expected(expected, msg);
1686 }
1687 try {
1688 Caller.putFieldTargetNotOurHostReflectively();
1689 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1690 }
1691 catch (IncompatibleClassChangeError expected) {
1692 check_expected(expected, msg);
1693 }
1694 try {
1695 Caller.putFieldTargetNotOurHostMH();
1696 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1697 }
1698 catch (IncompatibleClassChangeError expected) {
1699 check_expected(expected, msg);
1700 }
1701
1702 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1703 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1704 try {
1705 CallerNotOurHost.putFieldTarget();
1706 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1707 }
1708 catch (IncompatibleClassChangeError expected) {
1709 check_expected(expected, msg);
1710 }
1711 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1712 " of InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1713 try {
1714 CallerNotOurHost.putFieldTargetNotOurHost();
1715 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1716 }
1717 catch (IncompatibleClassChangeError expected) {
1718 check_expected(expected, msg);
1719 }
1720 }
1721
1722 static void test_WrongPackageHostPutField() {
1723 System.out.println("Testing for nest-host and nest-member in different packages");
1724 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
1725 "P1.PackagedNestHost (loader: 'app'): types are in different packages";
1726 try {
1727 P1.PackagedNestHost.doPutField();
1728 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1729 }
1730 catch (IncompatibleClassChangeError expected) {
1731 check_expected(expected, msg);
1732 }
1733 try {
1734 P2.PackagedNestHost2.Member.doPutField();
1735 throw new Error("Missing IncompatibleClassChangeError: " + msg);
1736 }
1737 catch (IncompatibleClassChangeError expected) {
1738 check_expected(expected, msg);
1739 }
1740 }
1741
1742 // utilities
1743
1744 static void check_expected(Throwable expected, String msg) {
1745 if (!expected.getMessage().contains(msg)) {
1746 throw new Error("Wrong " + expected.getClass().getSimpleName() +": \"" +
1747 expected.getMessage() + "\" does not contain \"" +
1748 msg + "\"");
1749 }
1750 System.out.println("OK - got expected exception: " + expected);
1751 }
1752
1753 static void check_expected(Throwable expected, String msg, String cause_msg) {
1754 if (!expected.getMessage().contains(msg)) {
1755 throw new Error("Wrong " + expected.getClass().getSimpleName() +": \"" +
1756 expected.getMessage() + "\" does not contain \"" +
1757 msg + "\"");
1758 }
1759 Throwable cause = expected.getCause();
1760 if (cause instanceof NoClassDefFoundError) {
1761 if (!cause.getMessage().contains(cause_msg)) {
1762 throw new Error(expected.getClass().getSimpleName() +
1763 " has wrong cause " + cause.getClass().getSimpleName() +": \"" +
1764 cause.getMessage() + "\" does not contain \"" +
1765 cause_msg + "\"");
1766 }
1767 }
1768 else throw new Error(expected.getClass().getSimpleName() +
1769 " has wrong cause " + cause.getClass().getSimpleName());
1770
1771 System.out.println("OK - got expected exception: " + expected +
1772 " with cause " + cause);
1773 }
1774
1775 }
|
1 /*
2 * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
680 check_expected(expected, msg);
681 }
682 msg = "TestNestmateMembership$Caller cannot access a member of class " +
683 "TestNestmateMembership$TargetNoHost with modifiers \"private static\"";
684 try {
685 Caller.invokeTargetNoHostReflectively();
686 throw new Error("Missing IllegalAccessException: " + msg);
687 }
688 catch (IllegalAccessException expected) {
689 check_expected(expected, msg);
690 }
691 msg = "no such method: TestNestmateMembership$TargetNoHost.m()void/invokeStatic";
692 try {
693 Caller.invokeTargetNoHostMH();
694 throw new Error("Missing IllegalAccessException: " + msg);
695 }
696 catch (IllegalAccessException expected) {
697 check_expected(expected, msg);
698 }
699
700 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
701 "method 'void TestNestmateMembership$Target.m()'";
702 try {
703 CallerNoHost.invokeTarget();
704 throw new Error("Missing IllegalAccessError: " + msg);
705 }
706 catch (IllegalAccessError expected) {
707 check_expected(expected, msg);
708 }
709 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
710 "method 'void TestNestmateMembership$TargetNoHost.m()'";
711 try {
712 CallerNoHost.invokeTargetNoHost();
713 throw new Error("Missing IllegalAccessError: " + msg);
714 }
715 catch (IllegalAccessError expected) {
716 check_expected(expected, msg);
717 }
718 }
719
720 static void test_SelfHostInvoke() throws Throwable {
721 System.out.println("Testing for class that lists itself as nest-host");
722 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
723 " of type TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member)";
724 try {
725 Caller.invokeTargetSelfHost();
726 throw new Error("Missing IllegalAccessError: " + msg);
727 }
728 catch (IllegalAccessError expected) {
729 check_expected(expected, msg);
730 }
731 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
732 "TestNestmateMembership$TargetSelfHost with modifiers \"private static\"";
733 try {
734 Caller.invokeTargetSelfHostReflectively();
735 throw new Error("Missing IllegalAccessError: " + msg);
736 }
737 catch (IllegalAccessException expected) {
738 check_expected(expected, msg);
739 }
740 msg = "no such method: TestNestmateMembership$TargetSelfHost.m()void/invokeStatic";
741 try {
742 Caller.invokeTargetSelfHostMH();
743 throw new Error("Missing IllegalAccessException: " + msg);
744 }
745 catch (IllegalAccessException expected) {
746 check_expected(expected, msg);
747 }
748
749 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
750 " of type TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
751 try {
752 CallerSelfHost.invokeTarget();
753 throw new Error("Missing IllegalAccessError: " + msg);
754 }
755 catch (IllegalAccessError expected) {
756 check_expected(expected, msg);
757 }
758 try {
759 CallerSelfHost.invokeTargetSelfHost();
760 throw new Error("Missing IllegalAccessError: " + msg);
761 }
762 catch (IllegalAccessError expected) {
763 check_expected(expected, msg);
764 }
765 }
766
767 static void test_MissingHostInvoke() throws Throwable {
768 System.out.println("Testing for nest-host class that does not exist");
769 String msg = "Nest host resolution of TestNestmateMembership$TargetMissingHost with host" +
770 " NoTargetMissingHost failed: java.lang.NoClassDefFoundError: NoTargetMissingHost";
771 try {
772 Caller.invokeTargetMissingHost();
773 throw new Error("Missing IllegalAccessError: " + msg);
774 }
775 catch (IllegalAccessError expected) {
776 check_expected(expected, msg);
777 }
778 msg = "class TestNestmateMembership$Caller cannot access a member of class" +
779 " TestNestmateMembership$TargetMissingHost with modifiers \"private static\"";
780 try {
781 Caller.invokeTargetMissingHostReflectively();
782 throw new Error("Missing IllegalAccessException: " + msg);
783 }
784 catch (IllegalAccessException expected) {
785 check_expected(expected, msg);
786 }
787 msg = "no such method: TestNestmateMembership$TargetMissingHost.m()void/invokeStatic";
788 try {
789 Caller.invokeTargetMissingHostMH();
790 throw new Error("Missing IllegalAccessException: " + msg);
791 }
792 catch (IllegalAccessException expected) {
793 check_expected(expected, msg);
794 }
795 msg = "no such method: TestNestmateMembership$TargetMissingHost.m()void/invokeStatic";
796 try {
797 Caller.invokeTargetMissingHostMH();
798 throw new Error("Missing IllegalAccessException: " + msg);
799 }
800 catch (IllegalAccessException expected) {
801 check_expected(expected, msg);
802 }
803
804 msg = "Nest host resolution of TestNestmateMembership$CallerMissingHost with host" +
805 " NoCallerMissingHost failed: java.lang.NoClassDefFoundError: NoCallerMissingHost";
806 try {
807 CallerMissingHost.invokeTarget();
808 throw new Error("Missing IllegalAccessError: " + msg);
809 }
810 catch (IllegalAccessError expected) {
811 check_expected(expected, msg);
812 }
813 try {
814 CallerMissingHost.invokeTargetMissingHost();
815 throw new Error("Missing IllegalAccessError: " + msg);
816 }
817 catch (IllegalAccessError expected) {
818 check_expected(expected, msg);
819 }
820 }
821
822 static void test_NotInstanceHostInvoke() throws Throwable {
823 System.out.println("Testing for nest-host class that is not an instance class");
824 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
825 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
826 try {
827 Caller.invokeTargetNotInstanceHost();
828 throw new Error("Missing IllegalAccessError: " + msg);
829 }
830 catch (IllegalAccessError expected) {
831 check_expected(expected, msg);
832 }
833 msg = "class TestNestmateMembership$Caller cannot access a member of class "+
834 "TestNestmateMembership$TargetNotInstanceHost with modifiers \"private static\"";
835 try {
836 Caller.invokeTargetNotInstanceHostReflectively();
837 throw new Error("Missing IllegalAccessException: " + msg);
838 }
839 catch (IllegalAccessException expected) {
840 check_expected(expected, msg);
841 }
842 msg = "no such method: TestNestmateMembership$TargetNotInstanceHost.m()void/invokeStatic";
843 try {
844 Caller.invokeTargetNotInstanceHostMH();
845 throw new Error("Missing IllegalAccessException: " + msg);
846 }
847 catch (IllegalAccessException expected) {
848 check_expected(expected, msg);
849 }
850
851 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a " +
852 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
853 try {
854 CallerNotInstanceHost.invokeTarget();
855 throw new Error("Missing IllegalAccessError: " + msg);
856 }
857 catch (IllegalAccessError expected) {
858 check_expected(expected, msg);
859 }
860 try {
861 CallerNotInstanceHost.invokeTargetNotInstanceHost();
862 throw new Error("Missing IllegalAccessError: " + msg);
863 }
864 catch (IllegalAccessError expected) {
865 check_expected(expected, msg);
866 }
867 }
868
869 static void test_NotOurHostInvoke() throws Throwable {
870 System.out.println("Testing for nest-host class that does not list us in its nest");
871 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a " +
872 "nest member of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
873 try {
874 Caller.invokeTargetNotOurHost();
875 throw new Error("Missing IllegalAccessError: " + msg);
876 }
877 catch (IllegalAccessError expected) {
878 check_expected(expected, msg);
879 }
880 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
881 "TestNestmateMembership$TargetNotOurHost with modifiers \"private static\"";
882 try {
883 Caller.invokeTargetNotOurHostReflectively();
884 throw new Error("Missing IllegalAccessException: " + msg);
885 }
886 catch (IllegalAccessException expected) {
887 check_expected(expected, msg);
888 }
889 msg = "no such method: TestNestmateMembership$TargetNotOurHost.m()void/invokeStatic";
890 try {
891 Caller.invokeTargetNotOurHostMH();
892 throw new Error("Missing IllegalAccessException: " + msg);
893 }
894 catch (IllegalAccessException expected) {
895 check_expected(expected, msg);
896 }
897
898 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
899 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
900 try {
901 CallerNotOurHost.invokeTarget();
902 throw new Error("Missing IllegalAccessError: " + msg);
903 }
904 catch (IllegalAccessError expected) {
905 check_expected(expected, msg);
906 }
907 try {
908 CallerNotOurHost.invokeTargetNotOurHost();
909 throw new Error("Missing IllegalAccessError: " + msg);
910 }
911 catch (IllegalAccessError expected) {
912 check_expected(expected, msg);
913 }
914 }
915
916 static void test_WrongPackageHostInvoke() {
917 System.out.println("Testing for nest-host and nest-member in different packages");
918 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
919 "type P1.PackagedNestHost (loader: 'app'): types are in different packages";
920 try {
921 P1.PackagedNestHost.doInvoke();
922 throw new Error("Missing IllegalAccessError: " + msg);
923 }
924 catch (IllegalAccessError expected) {
925 check_expected(expected, msg);
926 }
927 try {
928 P2.PackagedNestHost2.Member.doInvoke();
929 throw new Error("Missing IllegalAccessError: " + msg);
930 }
931 catch (IllegalAccessError expected) {
932 check_expected(expected, msg);
933 }
934 }
935
936 // constructor tests
937
938 static void test_GoodConstruct(){
939 try {
940 Caller.newTarget();
941 }
942 catch (Exception e) {
943 throw new Error("Unexpected exception on good construction: " + e);
944 }
945 }
946
947 static void test_NoHostConstruct() throws Throwable {
948 System.out.println("Testing for missing nest-host attribute");
949 String msg = "class TestNestmateMembership$Caller tried to access private " +
950 "method 'void TestNestmateMembership$TargetNoHost.<init>()'";
951 try {
952 Caller.newTargetNoHost();
953 throw new Error("Missing IllegalAccessError: " + msg);
954 }
955 catch (IllegalAccessError expected) {
956 check_expected(expected, msg);
957 }
958 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
959 "TestNestmateMembership$TargetNoHost with modifiers \"private\"";
960 try {
961 Caller.newTargetNoHostReflectively();
962 throw new Error("Missing IllegalAccessException: " + msg);
963 }
964 catch (IllegalAccessException expected) {
965 check_expected(expected, msg);
966 }
967 msg = "no such constructor: TestNestmateMembership$TargetNoHost.<init>()void/newInvokeSpecial";
968 try {
969 Caller.newTargetNoHostMH();
970 throw new Error("Missing IllegalAccessException: " + msg);
971 }
972 catch (IllegalAccessException expected) {
973 check_expected(expected, msg);
974 }
975
976 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
977 "method 'void TestNestmateMembership$Target.<init>()'";
978 try {
979 CallerNoHost.newTarget();
980 throw new Error("Missing IllegalAccessError: " + msg);
981 }
982 catch (IllegalAccessError expected) {
983 check_expected(expected, msg);
984 }
985 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
986 "method 'void TestNestmateMembership$TargetNoHost.<init>()'";
987 try {
988 CallerNoHost.newTargetNoHost();
989 throw new Error("Missing IllegalAccessError: " + msg);
990 }
991 catch (IllegalAccessError expected) {
992 check_expected(expected, msg);
993 }
994 }
995
996 static void test_SelfHostConstruct() throws Throwable {
997 System.out.println("Testing for class that lists itself as nest-host");
998 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
999 " of type TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
1000 try {
1001 Caller.newTargetSelfHost();
1002 throw new Error("Missing IllegalAccessError: " + msg);
1003 }
1004 catch (IllegalAccessError expected) {
1005 check_expected(expected, msg);
1006 }
1007 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1008 "TestNestmateMembership$TargetSelfHost with modifiers \"private\"";
1009 try {
1010 Caller.newTargetSelfHostReflectively();
1011 throw new Error("Missing IllegalAccessException: " + msg);
1012 }
1013 catch (IllegalAccessException expected) {
1014 check_expected(expected, msg);
1015 }
1016 msg = "no such constructor: TestNestmateMembership$TargetSelfHost.<init>()void/newInvokeSpecial";
1017 try {
1018 Caller.newTargetSelfHostMH();
1019 throw new Error("Missing IllegalAccessException: " + msg);
1020 }
1021 catch (IllegalAccessException expected) {
1022 check_expected(expected, msg);
1023 }
1024
1025 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1026 " of type TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1027 try {
1028 CallerSelfHost.newTarget();
1029 throw new Error("Missing IllegalAccessError: " + msg);
1030 }
1031 catch (IllegalAccessError expected) {
1032 check_expected(expected, msg);
1033 }
1034 try {
1035 CallerSelfHost.newTargetSelfHost();
1036 throw new Error("Missing IllegalAccessError: " + msg);
1037 }
1038 catch (IllegalAccessError expected) {
1039 check_expected(expected, msg);
1040 }
1041 }
1042
1043 static void test_MissingHostConstruct() throws Throwable {
1044 System.out.println("Testing for nest-host class that does not exist");
1045 String msg = "Nest host resolution of TestNestmateMembership$TargetMissingHost with " +
1046 "host NoTargetMissingHost failed: java.lang.NoClassDefFoundError: NoTargetMissingHost";
1047 try {
1048 Caller.newTargetMissingHost();
1049 throw new Error("Missing IllegalAccessError: " + msg);
1050 }
1051 catch (IllegalAccessError expected) {
1052 check_expected(expected, msg);
1053 }
1054 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1055 "TestNestmateMembership$TargetMissingHost with modifiers \"private\"";
1056 try {
1057 Caller.newTargetMissingHostReflectively();
1058 throw new Error("Missing IllegalAccessException: " + msg);
1059 }
1060 catch (IllegalAccessException expected) {
1061 check_expected(expected, msg);
1062 }
1063 msg = "no such constructor: TestNestmateMembership$TargetMissingHost.<init>()void/newInvokeSpecial";
1064 try {
1065 Caller.newTargetMissingHostMH();
1066 throw new Error("Missing IllegalAccessException: " + msg);
1067 }
1068 catch (IllegalAccessException expected) {
1069 check_expected(expected, msg);
1070 }
1071
1072 msg = "Nest host resolution of TestNestmateMembership$CallerMissingHost with host " +
1073 "NoCallerMissingHost failed: java.lang.NoClassDefFoundError: NoCallerMissingHost";
1074 try {
1075 CallerMissingHost.newTarget();
1076 throw new Error("Missing IllegalAccessError: " + msg);
1077 }
1078 catch (IllegalAccessError expected) {
1079 check_expected(expected, msg);
1080 }
1081 try {
1082 CallerMissingHost.newTargetMissingHost();
1083 throw new Error("Missing IllegalAccessError: " + msg);
1084 }
1085 catch (IllegalAccessError expected) {
1086 check_expected(expected, msg);
1087 }
1088 }
1089
1090 static void test_NotInstanceHostConstruct() throws Throwable {
1091 System.out.println("Testing for nest-host class that is not an instance class");
1092 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
1093 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
1094 try {
1095 Caller.newTargetNotInstanceHost();
1096 throw new Error("Missing IllegalAccessError: " + msg);
1097 }
1098 catch (IllegalAccessError expected) {
1099 check_expected(expected, msg);
1100 }
1101 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1102 "TestNestmateMembership$TargetNotInstanceHost with modifiers \"private\"";
1103 try {
1104 Caller.newTargetNotInstanceHostReflectively();
1105 throw new Error("Missing IllegalAccessException: " + msg);
1106 }
1107 catch (IllegalAccessException expected) {
1108 check_expected(expected, msg);
1109 }
1110 msg = "no such constructor: TestNestmateMembership$TargetNotInstanceHost.<init>()void/newInvokeSpecial";
1111 try {
1112 Caller.newTargetNotInstanceHostMH();
1113 throw new Error("Missing IllegalAccessException: " + msg);
1114 }
1115 catch (IllegalAccessException expected) {
1116 check_expected(expected, msg);
1117 }
1118
1119 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1120 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
1121 try {
1122 CallerNotInstanceHost.newTarget();
1123 throw new Error("Missing IllegalAccessError: " + msg);
1124 }
1125 catch (IllegalAccessError expected) {
1126 check_expected(expected, msg);
1127 }
1128 try {
1129 CallerNotInstanceHost.newTargetNotInstanceHost();
1130 throw new Error("Missing IllegalAccessError: " + msg);
1131 }
1132 catch (IllegalAccessError expected) {
1133 check_expected(expected, msg);
1134 }
1135 }
1136
1137 static void test_NotOurHostConstruct() throws Throwable {
1138 System.out.println("Testing for nest-host class that does not list us in its nest");
1139 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
1140 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1141 try {
1142 Caller.newTargetNotOurHost();
1143 throw new Error("Missing IllegalAccessError: " + msg);
1144 }
1145 catch (IllegalAccessError expected) {
1146 check_expected(expected, msg);
1147 }
1148 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1149 "TestNestmateMembership$TargetNotOurHost with modifiers \"private\"";
1150 try {
1151 Caller.newTargetNotOurHostReflectively();
1152 throw new Error("Missing IllegalAccessException: " + msg);
1153 }
1154 catch (IllegalAccessException expected) {
1155 check_expected(expected, msg);
1156 }
1157 msg = "no such constructor: TestNestmateMembership$TargetNotOurHost.<init>()void/newInvokeSpecial";
1158 try {
1159 Caller.newTargetNotOurHostMH();
1160 throw new Error("Missing IllegalAccessException: " + msg);
1161 }
1162 catch (IllegalAccessException expected) {
1163 check_expected(expected, msg);
1164 }
1165
1166 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1167 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1168 try {
1169 CallerNotOurHost.newTarget();
1170 throw new Error("Missing IllegalAccessError: " + msg);
1171 }
1172 catch (IllegalAccessError expected) {
1173 check_expected(expected, msg);
1174 }
1175 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1176 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1177 try {
1178 CallerNotOurHost.newTargetNotOurHost();
1179 throw new Error("Missing IllegalAccessError: " + msg);
1180 }
1181 catch (IllegalAccessError expected) {
1182 check_expected(expected, msg);
1183 }
1184 }
1185
1186 static void test_WrongPackageHostConstruct() {
1187 System.out.println("Testing for nest-host and nest-member in different packages");
1188 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
1189 "type P1.PackagedNestHost (loader: 'app'): types are in different packages";
1190 try {
1191 P1.PackagedNestHost.doConstruct();
1192 throw new Error("Missing IllegalAccessError: " + msg);
1193 }
1194 catch (IllegalAccessError expected) {
1195 check_expected(expected, msg);
1196 }
1197 try {
1198 P2.PackagedNestHost2.Member.doConstruct();
1199 throw new Error("Missing IllegalAccessError: " + msg);
1200 }
1201 catch (IllegalAccessError expected) {
1202 check_expected(expected, msg);
1203 }
1204 }
1205
1206 // field tests
1207
1208 static void test_GoodGetField(){
1209 try {
1210 Caller.getFieldTarget();
1211 }
1212 catch (Exception e) {
1213 throw new Error("Unexpected exception on good field access: " + e);
1214 }
1215 }
1216
1217 static void test_NoHostGetField() throws Throwable {
1218 System.out.println("Testing for missing nest-host attribute");
1219 String msg = "class TestNestmateMembership$Caller tried to access private " +
1220 "field TestNestmateMembership$TargetNoHost.f";
1221 try {
1222 Caller.getFieldTargetNoHost();
1223 throw new Error("Missing IllegalAccessError: " + msg);
1224 }
1225 catch (IllegalAccessError expected) {
1226 check_expected(expected, msg);
1227 }
1228 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1229 "TestNestmateMembership$TargetNoHost with modifiers \"private static\"";
1230 try {
1231 Caller.getFieldTargetNoHostReflectively();
1232 throw new Error("Missing IllegalAccessException: " + msg);
1233 }
1234 catch (IllegalAccessException expected) {
1235 check_expected(expected, msg);
1236 }
1237 msg = "member is private: TestNestmateMembership$TargetNoHost.f/int/getStatic";
1238 try {
1239 Caller.getFieldTargetNoHostMH();
1240 throw new Error("Missing IllegalAccessException: " + msg);
1241 }
1242 catch (IllegalAccessException expected) {
1243 check_expected(expected, msg);
1244 }
1245
1246 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1247 "field TestNestmateMembership$Target.f";
1248 try {
1249 CallerNoHost.getFieldTarget();
1250 throw new Error("Missing IllegalAccessError: " + msg);
1251 }
1252 catch (IllegalAccessError expected) {
1253 check_expected(expected, msg);
1254 }
1255 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1256 "field TestNestmateMembership$TargetNoHost.f";
1257 try {
1258 CallerNoHost.getFieldTargetNoHost();
1259 throw new Error("Missing IllegalAccessError: " + msg);
1260 }
1261 catch (IllegalAccessError expected) {
1262 check_expected(expected, msg);
1263 }
1264 }
1265
1266 static void test_SelfHostGetField() throws Throwable {
1267 System.out.println("Testing for class that lists itself as nest-host");
1268 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
1269 " of type TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
1270 try {
1271 Caller.getFieldTargetSelfHost();
1272 throw new Error("Missing IllegalAccessError: " + msg);
1273 }
1274 catch (IllegalAccessError expected) {
1275 check_expected(expected, msg);
1276 }
1277 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1278 "TestNestmateMembership$TargetSelfHost with modifiers \"private static\"";
1279 try {
1280 Caller.getFieldTargetSelfHostReflectively();
1281 throw new Error("Missing IllegalAccessException: " + msg);
1282 }
1283 catch (IllegalAccessException expected) {
1284 check_expected(expected, msg);
1285 }
1286 msg = "member is private: TestNestmateMembership$TargetSelfHost.f/int/getStatic, " +
1287 "from class TestNestmateMembership$Caller";
1288 try {
1289 Caller.getFieldTargetSelfHostMH();
1290 throw new Error("Missing IllegalAccessException: " + msg);
1291 }
1292 catch (IllegalAccessException expected) {
1293 check_expected(expected, msg);
1294 }
1295
1296 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1297 " of type TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1298 try {
1299 CallerSelfHost.getFieldTarget();
1300 throw new Error("Missing IllegalAccessError: " + msg);
1301 }
1302 catch (IllegalAccessError expected) {
1303 check_expected(expected, msg);
1304 }
1305 try {
1306 CallerSelfHost.getFieldTargetSelfHost();
1307 throw new Error("Missing IllegalAccessError: " + msg);
1308 }
1309 catch (IllegalAccessError expected) {
1310 check_expected(expected, msg);
1311 }
1312 }
1313
1314 static void test_MissingHostGetField() throws Throwable {
1315 System.out.println("Testing for nest-host class that does not exist");
1316 String msg = "Nest host resolution of TestNestmateMembership$TargetMissingHost with " +
1317 "host NoTargetMissingHost failed: java.lang.NoClassDefFoundError: NoTargetMissingHost";
1318 try {
1319 Caller.getFieldTargetMissingHost();
1320 throw new Error("Missing IllegalAccessError: " + msg);
1321 }
1322 catch (IllegalAccessError expected) {
1323 check_expected(expected, msg);
1324 }
1325 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1326 "TestNestmateMembership$TargetMissingHost with modifiers \"private static\"";
1327 try {
1328 Caller.getFieldTargetMissingHostReflectively();
1329 throw new Error("Missing IllegalAccessException: " + msg);
1330 }
1331 catch (IllegalAccessException expected) {
1332 check_expected(expected, msg);
1333 }
1334 msg = "member is private: TestNestmateMembership$TargetMissingHost.f/int/getStatic, " +
1335 "from class TestNestmateMembership$Caller";
1336 try {
1337 Caller.getFieldTargetMissingHostMH();
1338 throw new Error("Missing IllegalAccessException: " + msg);
1339 }
1340 catch (IllegalAccessException expected) {
1341 check_expected(expected, msg);
1342 }
1343
1344 msg = "Nest host resolution of TestNestmateMembership$CallerMissingHost with " +
1345 "host NoCallerMissingHost failed: java.lang.NoClassDefFoundError: NoCallerMissingHost";
1346 try {
1347 CallerMissingHost.getFieldTarget();
1348 throw new Error("Missing IllegalAccessError: " + msg);
1349 }
1350 catch (IllegalAccessError expected) {
1351 check_expected(expected, msg);
1352 }
1353 try {
1354 CallerMissingHost.getFieldTargetMissingHost();
1355 throw new Error("Missing IllegalAccessError: " + msg);
1356 }
1357 catch (IllegalAccessError expected) {
1358 check_expected(expected, msg);
1359 }
1360 }
1361
1362 static void test_NotInstanceHostGetField() throws Throwable {
1363 System.out.println("Testing for nest-host class that is not an instance class");
1364 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
1365 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
1366 try {
1367 Caller.getFieldTargetNotInstanceHost();
1368 throw new Error("Missing IllegalAccessError: " + msg);
1369 }
1370 catch (IllegalAccessError expected) {
1371 check_expected(expected, msg);
1372 }
1373 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1374 "TestNestmateMembership$TargetNotInstanceHost with modifiers \"private static\"";
1375 try {
1376 Caller.getFieldTargetNotInstanceHostReflectively();
1377 throw new Error("Missing IllegalAccessException: " + msg);
1378 }
1379 catch (IllegalAccessException expected) {
1380 check_expected(expected, msg);
1381 }
1382 msg = "member is private: TestNestmateMembership$TargetNotInstanceHost.f/int/getStatic, " +
1383 "from class TestNestmateMembership$Caller";
1384 try {
1385 Caller.getFieldTargetNotInstanceHostMH();
1386 throw new Error("Missing IllegalAccessException: " + msg);
1387 }
1388 catch (IllegalAccessException expected) {
1389 check_expected(expected, msg);
1390 }
1391
1392 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1393 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
1394 try {
1395 CallerNotInstanceHost.getFieldTarget();
1396 throw new Error("Missing IllegalAccessError: " + msg);
1397 }
1398 catch (IllegalAccessError expected) {
1399 check_expected(expected, msg);
1400 }
1401 try {
1402 CallerNotInstanceHost.getFieldTargetNotInstanceHost();
1403 throw new Error("Missing IllegalAccessError: " + msg);
1404 }
1405 catch (IllegalAccessError expected) {
1406 check_expected(expected, msg);
1407 }
1408 }
1409
1410 static void test_NotOurHostGetField() throws Throwable {
1411 System.out.println("Testing for nest-host class that does not list us in its nest");
1412 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
1413 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1414 try {
1415 Caller.getFieldTargetNotOurHost();
1416 throw new Error("Missing IllegalAccessError: " + msg);
1417 }
1418 catch (IllegalAccessError expected) {
1419 check_expected(expected, msg);
1420 }
1421 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1422 "TestNestmateMembership$TargetNotOurHost with modifiers \"private static\"";
1423 try {
1424 Caller.getFieldTargetNotOurHostReflectively();
1425 throw new Error("Missing IllegalAccessException: " + msg);
1426 }
1427 catch (IllegalAccessException expected) {
1428 check_expected(expected, msg);
1429 }
1430 msg = "member is private: TestNestmateMembership$TargetNotOurHost.f/int/getStatic, " +
1431 "from class TestNestmateMembership$Caller";
1432 try {
1433 Caller.getFieldTargetNotOurHostMH();
1434 throw new Error("Missing IllegalAccessException: " + msg);
1435 }
1436 catch (IllegalAccessException expected) {
1437 check_expected(expected, msg);
1438 }
1439
1440 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1441 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1442 try {
1443 CallerNotOurHost.getFieldTarget();
1444 throw new Error("Missing IllegalAccessError: " + msg);
1445 }
1446 catch (IllegalAccessError expected) {
1447 check_expected(expected, msg);
1448 }
1449 try {
1450 CallerNotOurHost.getFieldTargetNotOurHost();
1451 throw new Error("Missing IllegalAccessError: " + msg);
1452 }
1453 catch (IllegalAccessError expected) {
1454 check_expected(expected, msg);
1455 }
1456 }
1457
1458 static void test_WrongPackageHostGetField() {
1459 System.out.println("Testing for nest-host and nest-member in different packages");
1460 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
1461 "type P1.PackagedNestHost (loader: 'app'): types are in different packages";
1462 try {
1463 P1.PackagedNestHost.doGetField();
1464 throw new Error("Missing IllegalAccessError: " + msg);
1465 }
1466 catch (IllegalAccessError expected) {
1467 check_expected(expected, msg);
1468 }
1469 try {
1470 P2.PackagedNestHost2.Member.doGetField();
1471 throw new Error("Missing IllegalAccessError: " + msg);
1472 }
1473 catch (IllegalAccessError expected) {
1474 check_expected(expected, msg);
1475 }
1476 }
1477
1478 static void test_GoodPutField(){
1479 try {
1480 Caller.putFieldTarget();
1481 }
1482 catch (Exception e) {
1483 throw new Error("Unexpected exception on good field access: " + e);
1484 }
1485 }
1486
1487 static void test_NoHostPutField() throws Throwable {
1488 System.out.println("Testing for missing nest-host attribute");
1489 String msg = "class TestNestmateMembership$Caller tried to access private " +
1490 "field TestNestmateMembership$TargetNoHost.f";
1491 try {
1492 Caller.putFieldTargetNoHost();
1493 throw new Error("Missing IllegalAccessError: " + msg);
1494 }
1495 catch (IllegalAccessError expected) {
1496 check_expected(expected, msg);
1497 }
1498 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1499 "TestNestmateMembership$TargetNoHost with modifiers \"private static\"";
1500 try {
1501 Caller.putFieldTargetNoHostReflectively();
1502 throw new Error("Missing IllegalAccessException: " + msg);
1503 }
1504 catch (IllegalAccessException expected) {
1505 check_expected(expected, msg);
1506 }
1507 msg = "member is private: TestNestmateMembership$TargetNoHost.f/int/putStatic";
1508 try {
1509 Caller.putFieldTargetNoHostMH();
1510 throw new Error("Missing IllegalAccessException: " + msg);
1511 }
1512 catch (IllegalAccessException expected) {
1513 check_expected(expected, msg);
1514 }
1515
1516 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1517 "field TestNestmateMembership$Target.f";
1518 try {
1519 CallerNoHost.putFieldTarget();
1520 throw new Error("Missing IllegalAccessError: " + msg);
1521 }
1522 catch (IllegalAccessError expected) {
1523 check_expected(expected, msg);
1524 }
1525 msg = "class TestNestmateMembership$CallerNoHost tried to access private " +
1526 "field TestNestmateMembership$TargetNoHost.f";
1527 try {
1528 CallerNoHost.putFieldTargetNoHost();
1529 throw new Error("Missing IllegalAccessError: " + msg);
1530 }
1531 catch (IllegalAccessError expected) {
1532 check_expected(expected, msg);
1533 }
1534 }
1535
1536 static void test_SelfHostPutField() throws Throwable {
1537 System.out.println("Testing for class that lists itself as nest-host");
1538 String msg = "Type TestNestmateMembership$TargetSelfHost (loader: 'app') is not a nest member" +
1539 " of type TestNestmateMembership$TargetSelfHost (loader: 'app'): current type is not listed as a nest member";
1540 try {
1541 Caller.putFieldTargetSelfHost();
1542 throw new Error("Missing IllegalAccessError: " + msg);
1543 }
1544 catch (IllegalAccessError expected) {
1545 check_expected(expected, msg);
1546 }
1547 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1548 "TestNestmateMembership$TargetSelfHost with modifiers \"private static\"";
1549 try {
1550 Caller.putFieldTargetSelfHostReflectively();
1551 throw new Error("Missing IllegalAccessException: " + msg);
1552 }
1553 catch (IllegalAccessException expected) {
1554 check_expected(expected, msg);
1555 }
1556 msg = "member is private: TestNestmateMembership$TargetSelfHost.f/int/putStatic, " +
1557 "from class TestNestmateMembership$Caller";
1558 try {
1559 Caller.putFieldTargetSelfHostMH();
1560 throw new Error("Missing IllegalAccessException: " + msg);
1561 }
1562 catch (IllegalAccessException expected) {
1563 check_expected(expected, msg);
1564 }
1565
1566 msg = "Type TestNestmateMembership$CallerSelfHost (loader: 'app') is not a nest member" +
1567 " of type TestNestmateMembership$CallerSelfHost (loader: 'app'): current type is not listed as a nest member";
1568 try {
1569 CallerSelfHost.putFieldTarget();
1570 throw new Error("Missing IllegalAccessError: " + msg);
1571 }
1572 catch (IllegalAccessError expected) {
1573 check_expected(expected, msg);
1574 }
1575 try {
1576 CallerSelfHost.putFieldTargetSelfHost();
1577 throw new Error("Missing IllegalAccessError: " + msg);
1578 }
1579 catch (IllegalAccessError expected) {
1580 check_expected(expected, msg);
1581 }
1582 }
1583
1584 static void test_MissingHostPutField() throws Throwable {
1585 System.out.println("Testing for nest-host class that does not exist");
1586 String msg = "Nest host resolution of TestNestmateMembership$TargetMissingHost with " +
1587 "host NoTargetMissingHost failed: java.lang.NoClassDefFoundError: NoTargetMissingHost";
1588 try {
1589 Caller.putFieldTargetMissingHost();
1590 throw new Error("Missing IllegalAccessError: " + msg);
1591 }
1592 catch (IllegalAccessError expected) {
1593 check_expected(expected, msg);
1594 }
1595 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1596 "TestNestmateMembership$TargetMissingHost with modifiers \"private static\"";
1597 try {
1598 Caller.putFieldTargetMissingHostReflectively();
1599 throw new Error("Missing IllegalAccessException: " + msg);
1600 }
1601 catch (IllegalAccessException expected) {
1602 check_expected(expected, msg);
1603 }
1604 msg = "member is private: TestNestmateMembership$TargetMissingHost.f/int/putStatic, " +
1605 "from class TestNestmateMembership$Caller";
1606 try {
1607 Caller.putFieldTargetMissingHostMH();
1608 throw new Error("Missing IllegalAccessException: " + msg);
1609 }
1610 catch (IllegalAccessException expected) {
1611 check_expected(expected, msg);
1612 }
1613 msg = "Nest host resolution of TestNestmateMembership$CallerMissingHost with host " +
1614 "NoCallerMissingHost failed: java.lang.NoClassDefFoundError: NoCallerMissingHost";
1615 try {
1616 CallerMissingHost.putFieldTarget();
1617 throw new Error("Missing IllegalAccessError: " + msg);
1618 }
1619 catch (IllegalAccessError expected) {
1620 check_expected(expected, msg);
1621 }
1622 try {
1623 CallerMissingHost.putFieldTargetMissingHost();
1624 throw new Error("Missing IllegalAccessError: " + msg);
1625 }
1626 catch (IllegalAccessError expected) {
1627 check_expected(expected, msg);
1628 }
1629 }
1630
1631 static void test_NotInstanceHostPutField() throws Throwable {
1632 System.out.println("Testing for nest-host class that is not an instance class");
1633 String msg = "Type TestNestmateMembership$TargetNotInstanceHost (loader: 'app') is not a "+
1634 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
1635 try {
1636 Caller.putFieldTargetNotInstanceHost();
1637 throw new Error("Missing IllegalAccessError: " + msg);
1638 }
1639 catch (IllegalAccessError expected) {
1640 check_expected(expected, msg);
1641 }
1642 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1643 "TestNestmateMembership$TargetNotInstanceHost with modifiers \"private static\"";
1644 try {
1645 Caller.putFieldTargetNotInstanceHostReflectively();
1646 throw new Error("Missing IllegalAccessException: " + msg);
1647 }
1648 catch (IllegalAccessException expected) {
1649 check_expected(expected, msg);
1650 }
1651 msg = "member is private: TestNestmateMembership$TargetNotInstanceHost.f/int/putStatic, " +
1652 "from class TestNestmateMembership$Caller";
1653 try {
1654 Caller.putFieldTargetNotInstanceHostMH();
1655 throw new Error("Missing IllegalAccessException: " + msg);
1656 }
1657 catch (IllegalAccessException expected) {
1658 check_expected(expected, msg);
1659 }
1660
1661 msg = "Type TestNestmateMembership$CallerNotInstanceHost (loader: 'app') is not a "+
1662 "nest member of type [LInvalidNestHost; (loader: 'app'): host is not an instance class";
1663 try {
1664 CallerNotInstanceHost.putFieldTarget();
1665 throw new Error("Missing IllegalAccessError: " + msg);
1666 }
1667 catch (IllegalAccessError expected) {
1668 check_expected(expected, msg);
1669 }
1670 try {
1671 CallerNotInstanceHost.putFieldTargetNotInstanceHost();
1672 throw new Error("Missing IllegalAccessError: " + msg);
1673 }
1674 catch (IllegalAccessError expected) {
1675 check_expected(expected, msg);
1676 }
1677 }
1678
1679 static void test_NotOurHostPutField() throws Throwable {
1680 System.out.println("Testing for nest-host class that does not list us in its nest");
1681 String msg = "Type TestNestmateMembership$TargetNotOurHost (loader: 'app') is not a nest member" +
1682 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1683 try {
1684 Caller.putFieldTargetNotOurHost();
1685 throw new Error("Missing IllegalAccessError: " + msg);
1686 }
1687 catch (IllegalAccessError expected) {
1688 check_expected(expected, msg);
1689 }
1690 msg = "class TestNestmateMembership$Caller cannot access a member of class " +
1691 "TestNestmateMembership$TargetNotOurHost with modifiers \"private static\"";
1692 try {
1693 Caller.putFieldTargetNotOurHostReflectively();
1694 throw new Error("Missing IllegalAccessException: " + msg);
1695 }
1696 catch (IllegalAccessException expected) {
1697 check_expected(expected, msg);
1698 }
1699 msg = "member is private: TestNestmateMembership$TargetNotOurHost.f/int/putStatic, " +
1700 "from class TestNestmateMembership$Caller";
1701 try {
1702 Caller.putFieldTargetNotOurHostMH();
1703 throw new Error("Missing IllegalAccessException: " + msg);
1704 }
1705 catch (IllegalAccessException expected) {
1706 check_expected(expected, msg);
1707 }
1708 msg = "Type TestNestmateMembership$CallerNotOurHost (loader: 'app') is not a nest member" +
1709 " of type InvalidNestHost (loader: 'app'): current type is not listed as a nest member";
1710 try {
1711 CallerNotOurHost.putFieldTarget();
1712 throw new Error("Missing IllegalAccessError: " + msg);
1713 }
1714 catch (IllegalAccessError expected) {
1715 check_expected(expected, msg);
1716 }
1717 try {
1718 CallerNotOurHost.putFieldTargetNotOurHost();
1719 throw new Error("Missing IllegalAccessError: " + msg);
1720 }
1721 catch (IllegalAccessError expected) {
1722 check_expected(expected, msg);
1723 }
1724 }
1725
1726 static void test_WrongPackageHostPutField() {
1727 System.out.println("Testing for nest-host and nest-member in different packages");
1728 String msg = "Type P2.PackagedNestHost2$Member (loader: 'app') is not a nest member of " +
1729 "type P1.PackagedNestHost (loader: 'app'): types are in different packages";
1730 try {
1731 P1.PackagedNestHost.doPutField();
1732 throw new Error("Missing IllegalAccessError: " + msg);
1733 }
1734 catch (IllegalAccessError expected) {
1735 check_expected(expected, msg);
1736 }
1737 try {
1738 P2.PackagedNestHost2.Member.doPutField();
1739 throw new Error("Missing IllegalAccessError: " + msg);
1740 }
1741 catch (IllegalAccessError expected) {
1742 check_expected(expected, msg);
1743 }
1744 }
1745
1746 // utilities
1747
1748 static void check_expected(Throwable expected, String msg) {
1749 if (!expected.getMessage().contains(msg)) {
1750 throw new Error("Wrong " + expected.getClass().getSimpleName() +": \"" +
1751 expected.getMessage() + "\" does not contain \"" +
1752 msg + "\"", expected);
1753 }
1754 System.out.println("OK - got expected exception: " + expected);
1755 }
1756 }
|