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 */ 23 24 /* 25 * @test 26 * @bug 8046171 27 * @summary Test the various rules for nest members and nest-hosts by 28 * triggering nestmate access checks on all possible paths 29 * @compile TestNestmateMembership.java 30 * PackagedNestHost.java 31 * PackagedNestHost2.java 32 * InvalidNestHost.java 33 * 34 * @compile TargetNoHost.jcod 35 * CallerNoHost.jcod 36 * TargetSelfHost.jcod 37 * CallerSelfHost.jcod 38 * TargetMissingHost.jcod 39 * CallerMissingHost.jcod 40 * TargetNotInstanceHost.jcod 41 * CallerNotInstanceHost.jcod 42 * TargetNotOurHost.jcod 43 * CallerNotOurHost.jcod 44 * PackagedNestHost.jcod 45 * PackagedNestHost2Member.jcod 46 * PackagedNestHostMember.jcod 47 * 48 * @run main/othervm TestNestmateMembership method 49 * @run main/othervm TestNestmateMembership constructor 50 * @run main/othervm TestNestmateMembership getField 51 * @run main/othervm TestNestmateMembership putField 52 * @run main/othervm -Xcomp TestNestmateMembership getField 53 */ 54 55 // We test all the "illegal" relationships between a nest member and its nest-host 56 // except for the case where the name of the nest-member matches the name listed 57 // in the nest-host, but resolves to a different class. There doesn't seem to 58 // be a way to construct that scenario. 59 // For each nested class below there is a corresponding .jcod file which breaks one 60 // of the rules regarding nest membership. For the package related tests we have 61 // additional PackageNestHost*.java sources.[1] 62 // 63 // Note that all the .java files must be compiled in the same step, while all 64 // .jcod files must be compiled in a later step. 65 66 // We test all the different nestmate access check paths: method invocation, constructor 67 // invocations, field get and field put. The test is invoked four times with each using 68 // a different test mode. Plus an extra Xcomp run for field access to hit ciField path. 69 // 70 // As access checking requires resolution and validation of the nest-host of 71 // both the caller class and the target class, we must check that all 72 // combinations of good/bad caller/target are checked for each of the 73 // possible errors: 74 // - no nest-host attribute 75 // - nest-host refers to self 76 // - nest-host class can not be found 77 // - nest-host class is not an instance class (but is in same package) 78 // - class is not a member of nest-host's nest (but is in same package) 79 // - class and nest-host are in different packages 80 // 81 // To provide coverage for reflection and MethodHandle paths through 82 // JVM_AreNestmates, we add reflection/MH accesses to a subset of the tests. 83 // We only need to test one case (for Caller.xxx) as all cases use the same path; further 84 // we don't need to test all failure cases, as all exceptions are equivalent in that regard, 85 // but for good measure we test the four basic error situations (eliding the different 86 // package test for simplicity). 87 // 88 // [1] In earlier versions the package-test was the final check done in nest membership 89 // validation, so we needed actual test classes in different packages that claimed 90 // membership. The final spec requires the package test to be done first, so it can 91 // be trivially tested by using Object as the nest-host. But we leave the explicit 92 // package tests as they are, and adjust the other tests so that a "bad host" is 93 // always in the same package. 94 95 import java.lang.invoke.*; 96 import static java.lang.invoke.MethodHandles.*; 97 import static java.lang.invoke.MethodType.*; 98 99 public class TestNestmateMembership { 100 101 static final MethodType VOID_T = MethodType.methodType(void.class); 102 103 static class Caller { 104 105 private Caller() {} 106 107 private static void m() { 108 System.out.println("Caller.m()"); 109 } 110 111 // direct static method invocations 112 113 public static void invokeTarget() { 114 Target.m(); 115 } 116 public static void invokeTargetNoHost() { 117 TargetNoHost.m(); 118 } 119 public static void invokeTargetSelfHost() { 120 TargetSelfHost.m(); 121 } 122 public static void invokeTargetMissingHost() { 123 TargetMissingHost.m(); 124 } 125 public static void invokeTargetNotInstanceHost() { 126 TargetNotInstanceHost.m(); 127 } 128 public static void invokeTargetNotOurHost() { 129 TargetNotOurHost.m(); 130 } 131 132 // reflective static method invocations 133 134 public static void invokeTargetNoHostReflectively() throws Throwable { 135 TargetNoHost.class.getDeclaredMethod("m", new Class<?>[0]).invoke(null, new Object[0]); 136 } 137 public static void invokeTargetSelfHostReflectively() throws Throwable { 138 TargetSelfHost.class.getDeclaredMethod("m", new Class<?>[0]).invoke(null, new Object[0]); 139 } 140 public static void invokeTargetMissingHostReflectively() throws Throwable { 141 TargetMissingHost.class.getDeclaredMethod("m", new Class<?>[0]).invoke(null, new Object[0]); 142 } 143 public static void invokeTargetNotInstanceHostReflectively() throws Throwable { 144 TargetNotInstanceHost.class.getDeclaredMethod("m", new Class<?>[0]).invoke(null, new Object[0]); 145 } 146 public static void invokeTargetNotOurHostReflectively() throws Throwable { 147 TargetNotOurHost.class.getDeclaredMethod("m", new Class<?>[0]).invoke(null, new Object[0]); 148 } 149 150 // MethodHandle static method lookup (no invoke as the lookup should fail) 151 152 public static void invokeTargetNoHostMH() throws Throwable { 153 MethodHandle mh = lookup().findStatic(TargetNoHost.class, "m", VOID_T); 154 } 155 public static void invokeTargetSelfHostMH() throws Throwable { 156 MethodHandle mh = lookup().findStatic(TargetSelfHost.class, "m", VOID_T); 157 } 158 public static void invokeTargetMissingHostMH() throws Throwable { 159 MethodHandle mh = lookup().findStatic(TargetMissingHost.class, "m", VOID_T); 160 } 161 public static void invokeTargetNotInstanceHostMH() throws Throwable { 162 MethodHandle mh = lookup().findStatic(TargetNotInstanceHost.class, "m", VOID_T); 163 } 164 public static void invokeTargetNotOurHostMH() throws Throwable { 165 MethodHandle mh = lookup().findStatic(TargetNotOurHost.class, "m", VOID_T); 166 } 167 168 169 // direct constructor invocations 170 171 public static void newTarget() { 172 Object o = new Target(); 173 } 174 public static void newTargetNoHost() { 175 Object o = new TargetNoHost(); 176 } 177 public static void newTargetSelfHost() { 178 Object o = new TargetSelfHost(); 179 } 180 public static void newTargetMissingHost() { 181 Object o = new TargetMissingHost(); 182 } 183 public static void newTargetNotInstanceHost() { 184 Object o = new TargetNotInstanceHost(); 185 } 186 public static void newTargetNotOurHost() { 187 Object o = new TargetNotOurHost(); 188 } 189 190 // reflective constructor invocations 191 192 public static void newTargetNoHostReflectively() throws Throwable { 193 Object o = TargetNoHost.class.getDeclaredConstructor(new Class<?>[0]).newInstance(new Object[0]); 194 } 195 public static void newTargetSelfHostReflectively() throws Throwable { 196 Object o = TargetSelfHost.class.getDeclaredConstructor(new Class<?>[0]).newInstance(new Object[0]); 197 } 198 public static void newTargetMissingHostReflectively() throws Throwable { 199 Object o = TargetMissingHost.class.getDeclaredConstructor(new Class<?>[0]).newInstance(new Object[0]); 200 } 201 public static void newTargetNotInstanceHostReflectively() throws Throwable { 202 Object o = TargetNotInstanceHost.class.getDeclaredConstructor(new Class<?>[0]).newInstance(new Object[0]); 203 } 204 public static void newTargetNotOurHostReflectively() throws Throwable { 205 Object o = TargetNotOurHost.class.getDeclaredConstructor(new Class<?>[0]).newInstance(new Object[0]); 206 } 207 208 // MethodHandle constructor lookup (no invoke as the lookup should fail) 209 210 public static void newTargetNoHostMH() throws Throwable { 211 MethodHandle mh = lookup().findConstructor(TargetNoHost.class, VOID_T); 212 } 213 public static void newTargetSelfHostMH() throws Throwable { 214 MethodHandle mh = lookup().findConstructor(TargetSelfHost.class, VOID_T); 215 } 216 public static void newTargetMissingHostMH() throws Throwable { 217 MethodHandle mh = lookup().findConstructor(TargetMissingHost.class, VOID_T); 218 } 219 public static void newTargetNotInstanceHostMH() throws Throwable { 220 MethodHandle mh = lookup().findConstructor(TargetNotInstanceHost.class, VOID_T); 221 } 222 public static void newTargetNotOurHostMH() throws Throwable { 223 MethodHandle mh = lookup().findConstructor(TargetNotOurHost.class, VOID_T); 224 } 225 226 private static int f; 227 228 // direct field accesses 229 230 public static void getFieldTarget() { 231 int x = Target.f; 232 } 233 public static void getFieldTargetNoHost() { 234 int x = TargetNoHost.f; 235 } 236 public static void getFieldTargetSelfHost() { 237 int x = TargetSelfHost.f; 238 } 239 public static void getFieldTargetMissingHost() { 240 int x = TargetMissingHost.f; 241 } 242 public static void getFieldTargetNotInstanceHost() { 243 int x = TargetNotInstanceHost.f; 244 } 245 public static void getFieldTargetNotOurHost() { 246 int x = TargetNotOurHost.f; 247 } 248 249 public static void putFieldTarget() { 250 Target.f = 42; 251 } 252 public static void putFieldTargetNoHost() { 253 TargetNoHost.f = 42; 254 } 255 public static void putFieldTargetSelfHost() { 256 TargetSelfHost.f = 42; 257 } 258 public static void putFieldTargetMissingHost() { 259 TargetMissingHost.f = 42; 260 } 261 public static void putFieldTargetNotInstanceHost() { 262 TargetNotInstanceHost.f = 42; 263 } 264 public static void putFieldTargetNotOurHost() { 265 TargetNotOurHost.f = 42; 266 } 267 268 // reflective field accesses 269 270 public static void getFieldTargetNoHostReflectively() throws Throwable { 271 int x = TargetNoHost.class.getDeclaredField("f").getInt(null); 272 } 273 public static void getFieldTargetSelfHostReflectively() throws Throwable { 274 int x = TargetSelfHost.class.getDeclaredField("f").getInt(null); 275 } 276 public static void getFieldTargetMissingHostReflectively() throws Throwable { 277 int x = TargetMissingHost.class.getDeclaredField("f").getInt(null); 278 } 279 public static void getFieldTargetNotInstanceHostReflectively() throws Throwable { 280 int x = TargetNotInstanceHost.class.getDeclaredField("f").getInt(null); 281 } 282 public static void getFieldTargetNotOurHostReflectively() throws Throwable { 283 int x = TargetNotOurHost.class.getDeclaredField("f").getInt(null); 284 } 285 286 public static void putFieldTargetNoHostReflectively() throws Throwable { 287 TargetNoHost.class.getDeclaredField("f").setInt(null, 42); 288 } 289 public static void putFieldTargetSelfHostReflectively() throws Throwable { 290 TargetSelfHost.class.getDeclaredField("f").setInt(null, 42); 291 } 292 public static void putFieldTargetMissingHostReflectively() throws Throwable { 293 TargetMissingHost.class.getDeclaredField("f").setInt(null, 42); 294 } 295 public static void putFieldTargetNotInstanceHostReflectively() throws Throwable { 296 TargetNotInstanceHost.class.getDeclaredField("f").setInt(null, 42); 297 } 298 public static void putFieldTargetNotOurHostReflectively() throws Throwable { 299 TargetNotOurHost.class.getDeclaredField("f").setInt(null, 42); 300 } 301 302 // MethodHandle field lookup (no access as the lookup will fail) 303 304 public static void getFieldTargetNoHostMH() throws Throwable { 305 MethodHandle mh = lookup().findStaticGetter(TargetNoHost.class, "f", int.class); 306 } 307 public static void getFieldTargetSelfHostMH() throws Throwable { 308 MethodHandle mh = lookup().findStaticGetter(TargetSelfHost.class, "f", int.class); 309 } 310 public static void getFieldTargetMissingHostMH() throws Throwable { 311 MethodHandle mh = lookup().findStaticGetter(TargetMissingHost.class, "f", int.class); 312 } 313 public static void getFieldTargetNotInstanceHostMH() throws Throwable { 314 MethodHandle mh = lookup().findStaticGetter(TargetNotInstanceHost.class, "f", int.class); 315 } 316 public static void getFieldTargetNotOurHostMH() throws Throwable { 317 MethodHandle mh = lookup().findStaticGetter(TargetNotOurHost.class, "f", int.class); 318 } 319 320 public static void putFieldTargetNoHostMH() throws Throwable { 321 MethodHandle mh = lookup().findStaticSetter(TargetNoHost.class, "f", int.class); 322 } 323 public static void putFieldTargetSelfHostMH() throws Throwable { 324 MethodHandle mh = lookup().findStaticSetter(TargetSelfHost.class, "f", int.class); 325 } 326 public static void putFieldTargetMissingHostMH() throws Throwable { 327 MethodHandle mh = lookup().findStaticSetter(TargetMissingHost.class, "f", int.class); 328 } 329 public static void putFieldTargetNotInstanceHostMH() throws Throwable { 330 MethodHandle mh = lookup().findStaticSetter(TargetNotInstanceHost.class, "f", int.class); 331 } 332 public static void putFieldTargetNotOurHostMH() throws Throwable { 333 MethodHandle mh = lookup().findStaticSetter(TargetNotOurHost.class, "f", int.class); 334 } 335 336 } 337 338 static class CallerNoHost { 339 340 // method invocations 341 342 private static void m() { 343 System.out.println("CallerNoHost.m() - java version"); 344 } 345 public static void invokeTarget() { 346 Target.m(); 347 } 348 public static void invokeTargetNoHost() { 349 TargetNoHost.m(); 350 } 351 352 // constructor invocations 353 354 private CallerNoHost() {} 355 356 public static void newTarget() { 357 Object o = new Target(); 358 } 359 public static void newTargetNoHost() { 360 Object o = new TargetNoHost(); 361 } 362 363 // field accesses 364 365 private static int f; 366 367 public static void getFieldTarget() { 368 int x = Target.f; 369 } 370 public static void getFieldTargetNoHost() { 371 int x = TargetNoHost.f; 372 } 373 374 public static void putFieldTarget() { 375 Target.f = 42; 376 } 377 public static void putFieldTargetNoHost() { 378 TargetNoHost.f = 42; 379 } 380 381 } 382 383 static class CallerSelfHost { 384 385 // method invocations 386 387 private static void m() { 388 System.out.println("CallerSelfHost.m() - java version"); 389 } 390 public static void invokeTarget() { 391 Target.m(); 392 } 393 public static void invokeTargetSelfHost() { 394 TargetSelfHost.m(); 395 } 396 397 // constructor invocations 398 399 private CallerSelfHost() {} 400 401 public static void newTarget() { 402 Object o = new Target(); 403 } 404 public static void newTargetSelfHost() { 405 Object o = new TargetSelfHost(); 406 } 407 408 // field accesses 409 410 private static int f; 411 412 public static void getFieldTarget() { 413 int x = Target.f; 414 } 415 public static void getFieldTargetSelfHost() { 416 int x = TargetSelfHost.f; 417 } 418 419 public static void putFieldTarget() { 420 Target.f = 42; 421 } 422 public static void putFieldTargetSelfHost() { 423 TargetSelfHost.f = 42; 424 } 425 426 } 427 428 static class CallerMissingHost { 429 String msg = "NoCallerMissingHost"; // for cp entry 430 431 // method invocations 432 433 private static void m() { 434 System.out.println("CallerMissingHost.m() - java version"); 435 } 436 public static void invokeTarget() { 437 Target.m(); 438 } 439 public static void invokeTargetMissingHost() { 440 TargetMissingHost.m(); 441 } 442 443 // constructor invocations 444 445 private CallerMissingHost() {} 446 447 public static void newTarget() { 448 Object o = new Target(); 449 } 450 public static void newTargetMissingHost() { 451 Object o = new TargetMissingHost(); 452 } 453 454 // field accesses 455 456 private static int f; 457 458 public static void getFieldTarget() { 459 int x = Target.f; 460 } 461 public static void getFieldTargetMissingHost() { 462 int x = TargetMissingHost.f; 463 } 464 public static void putFieldTarget() { 465 Target.f = 42; 466 } 467 public static void putFieldTargetMissingHost() { 468 TargetMissingHost.f = 42; 469 } 470 471 } 472 473 static class CallerNotInstanceHost { 474 Object[] oa; // create CP entry to use in jcod change 475 476 // method invocations 477 478 private static void m() { 479 System.out.println("CallerNotInstanceHost.m() - java version"); 480 } 481 public static void invokeTarget() { 482 Target.m(); 483 } 484 public static void invokeTargetNotInstanceHost() { 485 TargetNotInstanceHost.m(); 486 } 487 488 // constructor invocations 489 490 private CallerNotInstanceHost() {} 491 492 public static void newTarget() { 493 Object o = new Target(); 494 } 495 public static void newTargetNotInstanceHost() { 496 Object o = new TargetNotInstanceHost(); 497 } 498 499 // field accesses 500 501 private static int f; 502 503 public static void getFieldTarget() { 504 int x = Target.f; 505 } 506 public static void getFieldTargetNotInstanceHost() { 507 int x = TargetNotInstanceHost.f; 508 } 509 public static void putFieldTarget() { 510 Target.f = 42; 511 } 512 public static void putFieldTargetNotInstanceHost() { 513 TargetNotInstanceHost.f = 42; 514 } 515 } 516 517 static class CallerNotOurHost { 518 519 // method invocations 520 521 private static void m() { 522 System.out.println("CallerNotOurHost.m() - java version"); 523 } 524 public static void invokeTarget() { 525 Target.m(); 526 } 527 public static void invokeTargetNotOurHost() { 528 TargetNotOurHost.m(); 529 } 530 531 // constructor invocations 532 533 private CallerNotOurHost() {} 534 535 public static void newTarget() { 536 Object o = new Target(); 537 } 538 public static void newTargetNotOurHost() { 539 Object o = new TargetNotOurHost(); 540 } 541 542 // field accesses 543 544 private static int f; 545 546 public static void getFieldTarget() { 547 int x = Target.f; 548 } 549 public static void getFieldTargetNotOurHost() { 550 int x = TargetNotOurHost.f; 551 } 552 public static void putFieldTarget() { 553 Target.f = 42; 554 } 555 public static void putFieldTargetNotOurHost() { 556 TargetNotOurHost.f = 42; 557 } 558 559 } 560 561 static class Target { 562 private Target() {} 563 private static int f; 564 private static void m() { 565 System.out.println("Target.m()"); 566 } 567 } 568 569 static class TargetNoHost { 570 private TargetNoHost() {} 571 private static int f; 572 private static void m() { 573 System.out.println("TargetNoHost.m() - java version"); 574 } 575 } 576 577 static class TargetSelfHost { 578 private TargetSelfHost() {} 579 private static int f; 580 private static void m() { 581 System.out.println("TargetSelfHost.m() - java version"); 582 } 583 } 584 585 static class TargetMissingHost { 586 String msg = "NoTargetMissingHost"; // for cp entry 587 private TargetMissingHost() {} 588 private static int f; 589 private static void m() { 590 System.out.println("TargetMissingHost.m() - java version"); 591 } 592 } 593 594 static class TargetNotInstanceHost { 595 Object[] oa; // create CP entry to use in jcod change 596 private TargetNotInstanceHost() {} 597 private static int f; 598 private static void m() { 599 System.out.println("TargetNotInstanceHost.m() - java version"); 600 } 601 } 602 603 static class TargetNotOurHost { 604 private TargetNotOurHost() {} 605 private static int f; 606 private static void m() { 607 System.out.println("TargetNotOurHost.m() - java version"); 608 } 609 } 610 611 public static void main(String[] args) throws Throwable { 612 if (args.length < 1) { 613 throw new Error("Test mode argument must be one of: method, constructor, getField or putField"); 614 } 615 switch(args[0]) { 616 case "method": 617 System.out.println("TESTING METHOD INVOCATIONS:"); 618 test_GoodInvoke(); 619 test_NoHostInvoke(); 620 test_SelfHostInvoke(); 621 test_MissingHostInvoke(); 622 test_NotInstanceHostInvoke(); 623 test_NotOurHostInvoke(); 624 test_WrongPackageHostInvoke(); 625 break; 626 case "constructor": 627 System.out.println("TESTING CONSTRUCTOR INVOCATIONS:"); 628 test_GoodConstruct(); 629 test_NoHostConstruct(); 630 test_SelfHostConstruct(); 631 test_MissingHostConstruct(); 632 test_NotInstanceHostConstruct(); 633 test_NotOurHostConstruct(); 634 test_WrongPackageHostConstruct(); 635 break; 636 case "getField": 637 System.out.println("TESTING GETFIELD INVOCATIONS:"); 638 test_GoodGetField(); 639 test_NoHostGetField(); 640 test_SelfHostGetField(); 641 test_MissingHostGetField(); 642 test_NotInstanceHostGetField(); 643 test_NotOurHostGetField(); 644 test_WrongPackageHostGetField(); 645 break; 646 case "putField": 647 System.out.println("TESTING PUTFIELD INVOCATIONS:"); 648 test_GoodPutField(); 649 test_NoHostPutField(); 650 test_SelfHostPutField(); 651 test_MissingHostPutField(); 652 test_NotInstanceHostPutField(); 653 test_NotOurHostPutField(); 654 test_WrongPackageHostPutField(); 655 break; 656 default: 657 throw new Error("Uknown mode: " + args[0] + 658 ". Must be one of: method, constructor, getField or putField"); 659 } 660 } 661 662 static void test_GoodInvoke(){ 663 try { 664 Caller.invokeTarget(); 665 } 666 catch (Exception e) { 667 throw new Error("Unexpected exception on good invocation " + e); 668 } 669 } 670 671 static void test_NoHostInvoke() throws Throwable { 672 System.out.println("Testing for missing nest-host attribute"); 673 String msg = "class TestNestmateMembership$Caller tried to access " + 674 "private method 'void TestNestmateMembership$TargetNoHost.m()'"; 675 try { 676 Caller.invokeTargetNoHost(); 677 throw new Error("Missing IllegalAccessError: " + msg); 678 } 679 catch (IllegalAccessError expected) { 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 }