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 }
|
|