1/* 2 * Copyright (c) 2013, 2016, 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 8001457 8027477 8163113 27 * @author sogoel 28 * @summary Reflection api tests 29 * @modules jdk.compiler 30 * @build Helper 31 * @compile expectedFiles/ExpectedBase.java expectedFiles/ExpectedContainer.java 32 * @run main ReflectionTest 33 */ 34import java.io.File; 35import java.io.IOException; 36import java.lang.annotation.Annotation; 37import java.net.MalformedURLException; 38import java.net.URL; 39import java.net.URLClassLoader; 40import java.util.ArrayList; 41import java.util.Arrays; 42import java.util.List; 43 44import javax.tools.DiagnosticCollector; 45import javax.tools.JavaFileObject; 46 47import expectedFiles.ExpectedBase; 48import expectedFiles.ExpectedContainer; 49import java.util.Iterator; 50import java.util.regex.Pattern; 51 52/* 53 * Objective: 54 * Test the following 6 methods from java.lang.reflect.AnnotatedElement: 55 * - getAnnotation(Class<T>) 56 * - getAnnotations() 57 * - getDeclaredAnnotations() 58 * - getDeclaredAnnotation(Class<T>) // new method in JDK8 59 * - getAnnotationsByType(Class<T>) // new method in JDK8 60 * - getDeclaredAnnotationsByType(Class<T>) // new method in JDK8 61 * for multiple test cases, for example, BasicNonRepeatable case, BasicRepeatable case 62 * for each of the src types - class, method, field, package 63 * 64 * This test uses following three enums: 65 * 1. TestCase - Defines the ExpectedBase/ExpectedContainer values for each testCase 66 * - getTestFiles() - Creates list of JavaFileObjects for the primary 67 * src types (class, method, field, package) 68 * - Each testCase is a new scenario with a combination of @Repeatable 69 * relationship present/absent in conjunction with @Inherited. 70 * For eg: BasicNonRepeatable_Legacy - It is a pre-JDK8 way of writing a single 71 * annotation on a given srcType( class, method, field, package) 72 * BasicRepeatable - It is a JDK8 way of writing repeating annotations 73 * on a given srcType with a @Repeatable relationship 74 * defined between Foo and FooContainer. 75 * 76 * 2. SrcType - Defines templates used in creation of test src 77 * - Defines getExpectedBase() and getExpectedContainer() for primary src types 78 * 3. TestMethod - Defines getActualAnnoBase(), getActualAnnoContainer(), getExpectedAnnoBase(), 79 * and getExpectedAnnoContainer() for each of the 6 methods that are being tested 80 * in java.lang.reflect.AnnotatedElement 81 * 82 * Test execution flow: 83 * - Loop over each of the src types and each test cases 84 * - Creates test src for each flow, compile it, load the class object 85 * - Run all 6 methods on this class object 86 * - Get expected and actual annotations for each object and compare them. 87 * - Increment the error counter if the annotations don't match. 88 * 89 * The test fails if the number of errors is greater than 0. 90 */ 91public class ReflectionTest { 92 93 static int errors = 0; 94 // Variables used in creating test src for a given testcase/testSrcType 95 static final String TESTPKG = "testpkg"; 96 static final String TESTMETHOD = "testMethod"; 97 static final String TESTFIELD = "testField"; 98 static final String PKGINFONAME = TESTPKG + ".package-info"; 99 static final String SUPERCLASS = "SuperClass"; 100 static final String TESTINTERFACE = "TestInterface"; 101 /* 102 * Set it to true to get more debug information 103 */ 104 static final boolean DEBUG = false; 105 static boolean CHECKORDERING; 106 107 public static void main(String args[]) throws Exception { 108 ReflectionTest test = new ReflectionTest(); 109 test.runTest(); 110 } 111 112 public void runTest() throws Exception { 113 114 ClassLoader parentClassLoader = getLoader(); 115 String className = ""; 116 Iterable<? extends JavaFileObject> files = null; 117 118 for (SrcType srcType : SrcType.getSrcTypes()) { 119 for (TestCase testCase : TestCase.values()) { 120 className = testCase + "_" + srcType; 121 debugPrint("*****************************************"); 122 System.out.println("Running Test for ClassName: " + className); 123 124 // @Inherited only applicable for class, exclude cases for 125 // package, method, field 126 if (testCase.name().contains("Inherited") 127 && (srcType != SrcType.CLASS)) { 128 continue; 129 } 130 131 // Get list of JavaFileObjects to be compiled 132 files = testCase.getTestFiles(srcType, className); 133 if (srcType == SrcType.PACKAGE) { 134 className = TESTPKG + "." + className; 135 } 136 DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>(); 137 138 // Compile the list of JavaFileObjects 139 try { 140 Helper.compileCode(diagnostics, files); 141 } catch (Exception ex) { 142 printTestSrc(files); 143 throw new RuntimeException( 144 "Exception when compiling class " + className, ex); 145 } 146 147 // Get Class object for the compiled class 148 Class<?> c = loadClass(className, parentClassLoader, Helper.destDir); 149 if (c != null) { 150 // For the loaded class object, compare expected and actual annotation values 151 // for each of the methods under test from java.lang.reflect.AnnotatedElement 152 153 154 // Ignoring following test cases since for now they are 155 // failing with ordering issues. 156 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 157 // fail with ordering issues 158 List<String> orderingTestFailures = Arrays.asList( 159 "SingleOnSuperContainerOnSub_Inherited_Legacy", 160 "SingleOnSuperContainerAndSingleOnSub_Inherited_Legacy", 161 "ContainerAndSingleOnSuperSingleOnSub_Inherited_Legacy", 162 "SingleAnnoWithContainer", 163 "SingleOnSuperContainerAndSingleOnSub_Inherited", 164 "RepeatableOnSuperSingleOnSub_Inherited", 165 "SingleOnSuperRepeatableOnSub_Inherited", 166 "ContainerOnSuperSingleOnSub_Inherited", 167 "SingleOnSuperContainerOnSub_Inherited", 168 "ContainerAndSingleOnSuperSingleOnSub_Inherited"); 169 if (orderingTestFailures.contains(testCase.toString())) { 170 CHECKORDERING = false; 171 } else 172 CHECKORDERING = true; 173 174 checkAnnoValues(srcType, c); 175 } else { 176 error("Could not load className = " + c); 177 } 178 } 179 } 180 181 if (getNumErrors() > 0) { 182 System.err.println("Test failed with " + getNumErrors() + " errors"); 183 throw new RuntimeException(); 184 } 185 } 186 187 /* 188 * Each test case in this enum has the following: 189 * - Define each test case with its @ExpectedBase and @ExpectedContainer annotations 190 * - Override getTestFiles() that creates list of JavaFileObjects for each case 191 * based on the src type. 192 */ 193 enum TestCase { 194 BasicNonRepeatable_Legacy( 195 "@ExpectedBase(value=Foo.class, " 196 + "getAnnotationVal = \"@Foo(value=0)\", " 197 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}, " 198 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}, " 199 + "getDeclAnnoVal = \"@Foo(value=0)\", " 200 + "getAnnosArgs = {\"@Foo(value=0)\"}, " 201 + "getDeclAnnosArgs = {\"@Foo(value=0)\"}) ", 202 "@ExpectedContainer") { 203 204 @Override 205 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 206 String className) { 207 String anno = ""; 208 String replaceVal = ""; 209 String testSrc = ""; 210 String pkgInfoContents = ""; 211 String contents = ""; 212 213 JavaFileObject pkgFileObj = null; 214 JavaFileObject srcFileObj = null; 215 Iterable<? extends JavaFileObject> files = null; 216 217 String expectedVals = "\n" + getExpectedBase() + "\n" 218 + getExpectedContainer() + "\n"; 219 StringBuilder commonStmts = new StringBuilder(); 220 anno = Helper.ContentVars.BASEANNO.getVal(); 221 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 222 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 223 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 224 .append(Helper.ContentVars.BASE.getVal()); 225 switch (srcType) { 226 case PACKAGE: 227 /* 228 Sample package-info.java 229 @ExpectedBase 230 @ExpectedContainer 231 @Foo(0) 232 package testpkg; 233 234 @Retention(RetentionPolicy.RUNTIME) 235 @interface Foo {int value() default Integer.MAX_VALUE;} 236 237 Sample testSrc: 238 package testpkg; 239 class A {} 240 */ 241 testSrc = srcType.getTemplate().replace("#CN", className); 242 contents = testSrc; 243 srcFileObj = Helper.getFile(className, contents); 244 245 replaceVal = expectedVals + "\n" + anno; 246 pkgInfoContents = SrcType.PKGINFO.getTemplate() 247 .replace("#REPLACE1", replaceVal) 248 .replace("#REPLACE2", commonStmts); 249 pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents); 250 251 files = Arrays.asList(pkgFileObj, srcFileObj); 252 break; 253 default: 254 // class, method, field 255 /* 256 Sample testSrc for class 257 @Retention(RetentionPolicy.RUNTIME) 258 @interface Foo {int value() default Integer.MAX_VALUE;} 259 260 @ExpectedBase 261 @ExpectedContainer 262 @Foo(0) 263 class A {} 264 */ 265 replaceVal = expectedVals + anno; 266 testSrc = srcType.getTemplate().replace("#CN", className) 267 .replace("#REPLACE", replaceVal); 268 contents = commonStmts + testSrc; 269 srcFileObj = Helper.getFile(className, contents); 270 files = Arrays.asList(srcFileObj); 271 } 272 return files; 273 } 274 }, 275 SingleAnnoInherited_Legacy( 276 "@ExpectedBase(value=Foo.class, " 277 + "getAnnotationVal = \"@Foo(value=0)\", " 278 + "getAnnotationsVals = {\"@Foo(value=0)\", \"ExpectedBase\", \"ExpectedContainer\"}, " 279 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " 280 + "getDeclAnnoVal = \"NULL\", " 281 + "getAnnosArgs = {\"@Foo(value=0)\"}, " 282 + "getDeclAnnosArgs = {})", 283 "@ExpectedContainer") { 284 285 @Override 286 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 287 String className) { 288 String anno = ""; 289 String replaceVal = ""; 290 String contents = ""; 291 JavaFileObject srcFileObj = null; 292 Iterable<? extends JavaFileObject> files = null; 293 294 String expectedVals = "\n" + getExpectedBase() + "\n" 295 + getExpectedContainer() + "\n"; 296 StringBuilder commonStmts = new StringBuilder(); 297 298 /* 299 Sample testSrc: 300 @Retention(RetentionPolicy.RUNTIME) 301 @Inherited 302 @interface Foo {int value() default Integer.MAX_VALUE;} 303 304 @Foo(0) 305 class SuperClass { } 306 307 @ExpectedBase 308 @ExpectedContainer 309 class SubClass extends SuperClass {} 310 */ 311 312 // @Inherited only works for classes, no switch cases for 313 // method, field, package 314 anno = Helper.ContentVars.BASEANNO.getVal(); 315 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 316 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 317 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 318 .append(Helper.ContentVars.INHERITED.getVal()) 319 .append(Helper.ContentVars.BASE.getVal()); 320 321 if (srcType == SrcType.CLASS) { 322 // Contents for SuperClass 323 replaceVal = commonStmts + "\n" + anno; 324 String superClassContents = srcType.getTemplate() 325 .replace("#CN", SUPERCLASS).replace("#REPLACE", replaceVal); 326 327 // Contents for SubClass that extends SuperClass 328 replaceVal = expectedVals; 329 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 330 .replace("#CN", className).replace("#SN", SUPERCLASS) 331 .replace("#REPLACE", replaceVal); 332 333 contents = superClassContents + subClassContents; 334 srcFileObj = Helper.getFile(className, contents); 335 files = Arrays.asList(srcFileObj); 336 } 337 return files; 338 } 339 }, 340 InheritedAnnoOnInterface_Legacy( 341 "@ExpectedBase(value=Foo.class, " 342 + "getAnnotationVal = \"NULL\", " 343 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " 344 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}," 345 + "getDeclAnnoVal = \"NULL\"," + "getAnnosArgs = {}," 346 + "getDeclAnnosArgs = {})", 347 "@ExpectedContainer") { 348 349 @Override 350 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 351 String className) { 352 String anno = ""; 353 String replaceVal = ""; 354 String contents = ""; 355 JavaFileObject srcFileObj = null; 356 Iterable<? extends JavaFileObject> files = null; 357 358 String expectedVals = "\n" + getExpectedBase() + "\n" 359 + getExpectedContainer() + "\n"; 360 StringBuilder commonStmts = new StringBuilder(); 361 362 /* 363 Sample test src: 364 @Retention(RetentionPolicy.RUNTIME) 365 @Inherited 366 @interface Foo {int value() default Integer.MAX_VALUE;} 367 368 @Foo(0) 369 interface TestInterface { } 370 371 @ExpectedBase 372 @ExpectedContainer 373 class A implements TestInterface {} 374 */ 375 anno = Helper.ContentVars.BASEANNO.getVal(); 376 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 377 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 378 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 379 .append(Helper.ContentVars.INHERITED.getVal()) 380 .append(Helper.ContentVars.BASE.getVal()); 381 382 if (srcType == SrcType.CLASS) { 383 // Contents for TestInterface 384 replaceVal = commonStmts + "\n" + anno; 385 String interfaceContents = SrcType.INTERFACE.getTemplate() 386 .replace("#IN", TESTINTERFACE) 387 .replace("#REPLACE", replaceVal); 388 389 // Contents for class implementing TestInterface 390 replaceVal = expectedVals; 391 String classContents = SrcType.INTERFACEIMPL.getTemplate() 392 .replace("#CN", className).replace("#IN", TESTINTERFACE) 393 .replace("#REPLACE", replaceVal); 394 395 contents = interfaceContents + classContents; 396 srcFileObj = Helper.getFile(className, contents); 397 files = Arrays.asList(srcFileObj); 398 } 399 return files; 400 } 401 }, 402 AnnoOnSuperAndSubClass_Inherited_Legacy( 403 "@ExpectedBase(value=Foo.class, " 404 + "getAnnotationVal = \"@Foo(value=2)\", " 405 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, " 406 + // override every annotation on superClass 407 "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, " 408 + // ignores inherited annotations 409 "getDeclAnnoVal = \"@Foo(value=2)\", " // ignores inherited 410 + "getAnnosArgs = {\"@Foo(value=2)\"}, " 411 + "getDeclAnnosArgs = { \"@Foo(value=2)\" })", // ignores inherited 412 "@ExpectedContainer(value=FooContainer.class, " 413 + "getAnnotationVal = \"NULL\", " 414 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, " 415 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, " 416 + // ignores inherited annotations 417 "getDeclAnnoVal = \"NULL\", " + // ignores inherited 418 "getAnnosArgs = {}, " + "getDeclAnnosArgs = {})") { // ignores inherited 419 420 @Override 421 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 422 String className) { 423 String anno = ""; 424 String replaceVal = ""; 425 String contents = ""; 426 JavaFileObject srcFileObj = null; 427 Iterable<? extends JavaFileObject> files = null; 428 429 String expectedVals = "\n" + getExpectedBase() + "\n" 430 + getExpectedContainer() + "\n"; 431 StringBuilder commonStmts = new StringBuilder(); 432 433 /* 434 Sample test src 435 @Retention(RetentionPolicy.RUNTIME) 436 @Inherited 437 @interface Foo {int value() default Integer.MAX_VALUE;} 438 439 @Inherited 440 @interface FooContainer { 441 Foo[] value(); 442 } 443 444 @Foo(1) 445 class SuperClass { } 446 447 @ExpectedBase 448 @ExpectedContainer 449 @Foo(2) 450 class SubClass extends SuperClass {} 451 */ 452 // @Inherited only works for classes, no switch cases for 453 // method, field, package 454 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 455 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 456 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 457 .append(Helper.ContentVars.INHERITED.getVal()) 458 .append(Helper.ContentVars.BASE.getVal()) 459 .append(Helper.ContentVars.INHERITED.getVal()) 460 .append(Helper.ContentVars.CONTAINER.getVal()); 461 462 if (srcType == SrcType.CLASS) { 463 // Contents for SuperClass 464 anno = "@Foo(1)"; 465 replaceVal = commonStmts + "\n" + anno; 466 String superClassContents = srcType.getTemplate() 467 .replace("#CN", SUPERCLASS).replace("#REPLACE", replaceVal); 468 469 // Contents for SubClass that extends SuperClass 470 anno = "@Foo(2)"; 471 replaceVal = expectedVals + "\n" + anno; 472 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 473 .replace("#CN", className).replace("#SN", SUPERCLASS) 474 .replace("#REPLACE", replaceVal); 475 476 contents = superClassContents + subClassContents; 477 srcFileObj = Helper.getFile(className, contents); 478 files = Arrays.asList(srcFileObj); 479 } 480 return files; 481 } 482 }, 483 BasicContainer_Legacy( 484 "@ExpectedBase(value = Foo.class, " 485 + "getAnnotationVal = \"NULL\"," 486 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 487 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 488 + "getDeclAnnoVal = \"NULL\", " + "getAnnosArgs = {}, " 489 + "getDeclAnnosArgs = {} )", 490 "@ExpectedContainer(value=FooContainer.class, " 491 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 492 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 493 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 494 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 495 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 496 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { 497 498 @Override 499 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 500 String className) { 501 String anno = ""; 502 String replaceVal = ""; 503 String testSrc = ""; 504 String pkgInfoContents = ""; 505 String contents = ""; 506 507 JavaFileObject pkgFileObj = null; 508 JavaFileObject srcFileObj = null; 509 Iterable<? extends JavaFileObject> files = null; 510 511 String expectedVals = "\n" + getExpectedBase() + "\n" 512 + getExpectedContainer() + "\n"; 513 StringBuilder commonStmts = new StringBuilder(); 514 515 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 516 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 517 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 518 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 519 .append(Helper.ContentVars.BASE.getVal()) 520 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 521 .append(Helper.ContentVars.CONTAINER.getVal()); 522 switch (srcType) { 523 case PACKAGE: 524 /* 525 Sample package-info.java 526 @ExpectedBase 527 @ExpectedContainer 528 @FooContainer(value = {@Foo(1), @Foo(2)}) 529 package testpkg; 530 531 @Retention(RetentionPolicy.RUNTIME) 532 @interface Foo {int value() default Integer.MAX_VALUE;} 533 534 @Retention(RetentionPolicy.RUNTIME) 535 @interface FooContainer { 536 Foo[] value(); 537 } 538 539 Sample testSrc: 540 package testpkg; 541 class A {} 542 */ 543 testSrc = srcType.getTemplate().replace("#CN", className); 544 contents = testSrc; 545 srcFileObj = Helper.getFile(className, contents); 546 547 replaceVal = "\n" + expectedVals + "\n" + anno; 548 pkgInfoContents = SrcType.PKGINFO.getTemplate() 549 .replace("#REPLACE1", replaceVal) 550 .replace("#REPLACE2", commonStmts); 551 pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents); 552 files = Arrays.asList(pkgFileObj, srcFileObj); 553 break; 554 default: 555 /* 556 Sample testSrc for class: 557 @Retention(RetentionPolicy.RUNTIME) 558 @Inherited 559 @interface Foo {int value() default Integer.MAX_VALUE;} 560 561 @Retention(RetentionPolicy.RUNTIME) 562 @Inherited 563 @interface FooContainer { 564 Foo[] value(); 565 } 566 567 @ExpectedBase 568 @ExpectedContainer 569 @FooContainer(value = {@Foo(1), @Foo(2)}) 570 class A {} 571 */ 572 replaceVal = expectedVals + anno; 573 testSrc = srcType.getTemplate().replace("#CN", className) 574 .replace("#REPLACE", replaceVal); 575 contents = commonStmts + testSrc; 576 srcFileObj = Helper.getFile(className, contents); 577 files = Arrays.asList(srcFileObj); 578 } 579 return files; 580 } 581 }, 582 SingleAndContainerOnSuper_Legacy( 583 "@ExpectedBase(value = Foo.class, " 584 + "getAnnotationVal = \"@Foo(value=0)\"," 585 + "getAnnotationsVals = {" 586 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 587 + "getDeclAnnosVals = {" 588 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 589 + "getDeclAnnoVal = \"@Foo(value=0)\", " 590 + "getAnnosArgs = {\"@Foo(value=0)\"}, " 591 + "getDeclAnnosArgs = {\"@Foo(value=0)\"} )", 592 "@ExpectedContainer(value=FooContainer.class, " 593 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 594 + "getAnnotationsVals = {" 595 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 596 + "getDeclAnnosVals = {" 597 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 598 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 599 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 600 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { 601 602 @Override 603 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 604 String className) { 605 String anno = ""; 606 String replaceVal = ""; 607 String testSrc = ""; 608 String pkgInfoContents = ""; 609 String contents = ""; 610 611 JavaFileObject pkgFileObj = null; 612 JavaFileObject srcFileObj = null; 613 Iterable<? extends JavaFileObject> files = null; 614 615 String expectedVals = "\n" + getExpectedBase() + "\n" 616 + getExpectedContainer() + "\n"; 617 StringBuilder commonStmts = new StringBuilder(); 618 619 anno = Helper.ContentVars.BASEANNO.getVal() + 620 Helper.ContentVars.LEGACYCONTAINER.getVal(); 621 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 622 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 623 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 624 .append(Helper.ContentVars.BASE.getVal()) 625 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 626 .append(Helper.ContentVars.CONTAINER.getVal()); 627 switch (srcType) { 628 case PACKAGE: 629 /* 630 Sample package-info.java 631 @ExpectedBase 632 @ExpectedContainer 633 @Foo(0) 634 @FooContainer(value = {@Foo(1), @Foo(2)}) 635 package testpkg; 636 637 @Retention(RetentionPolicy.RUNTIME) 638 @interface Foo {int value() default Integer.MAX_VALUE;} 639 640 @Retention(RetentionPolicy.RUNTIME) 641 @interface FooContainer { 642 Foo[] value(); 643 } 644 645 Sample testSrc: 646 package testpkg; 647 class A {} 648 */ 649 testSrc = srcType.getTemplate().replace("#CN", className); 650 contents = testSrc; 651 652 srcFileObj = Helper.getFile(className, contents); 653 654 replaceVal = "\n" + expectedVals + "\n" + anno; 655 pkgInfoContents = SrcType.PKGINFO.getTemplate() 656 .replace("#REPLACE1", replaceVal) 657 .replace("#REPLACE2", commonStmts); 658 pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents); 659 files = Arrays.asList(pkgFileObj, srcFileObj); 660 break; 661 default: 662 /* 663 Sample testSrc for class: 664 @Retention(RetentionPolicy.RUNTIME) 665 @Inherited 666 @interface Foo {int value() default Integer.MAX_VALUE;} 667 668 @Retention(RetentionPolicy.RUNTIME) 669 @Inherited 670 @interface FooContainer { 671 Foo[] value(); 672 } 673 674 @ExpectedBase 675 @ExpectedContainer 676 @Foo(0) 677 @FooContainer(value = {@Foo(1), @Foo(2)}) 678 class A {} 679 */ 680 replaceVal = expectedVals + anno; 681 testSrc = srcType.getTemplate().replace("#CN", className) 682 .replace("#REPLACE", replaceVal); 683 contents = commonStmts + testSrc; 684 685 srcFileObj = Helper.getFile(className, contents); 686 files = Arrays.asList(srcFileObj); 687 } 688 return files; 689 } 690 }, 691 BasicContainer_Inherited_Legacy( 692 "@ExpectedBase(value = Foo.class, " 693 + "getAnnotationVal = \"NULL\"," 694 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 695 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " 696 + "getDeclAnnoVal = \"NULL\", " 697 + "getAnnosArgs = {}, " 698 + "getDeclAnnosArgs = {} )", 699 "@ExpectedContainer(value=FooContainer.class, " 700 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 701 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 702 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " 703 + "getDeclAnnoVal = \"NULL\", " 704 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 705 + "getDeclAnnosArgs = {} )") { 706 707 @Override 708 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 709 String className) { 710 String anno = ""; 711 String replaceVal = ""; 712 String contents = ""; 713 JavaFileObject srcFileObj = null; 714 Iterable<? extends JavaFileObject> files = null; 715 716 String expectedVals = "\n" + getExpectedBase() + "\n" 717 + getExpectedContainer() + "\n"; 718 StringBuilder commonStmts = getCommonStmts(false); 719 720 /* 721 Sample testSrc: 722 @Retention(RetentionPolicy.RUNTIME) 723 @Inherited 724 @interface Foo {int value() default Integer.MAX_VALUE;} 725 726 @Retention(RetentionPolicy.RUNTIME) 727 @Inherited 728 @interface FooContainer { 729 Foo[] value(); 730 } 731 732 @FooContainer(value = {@Foo(1), @Foo(2)}) 733 class SuperClass { } 734 735 @ExpectedBase 736 @ExpectedContainer 737 class SubClass extends SuperClass {} 738 */ 739 // @Inherited only works for classes, no switch cases for 740 // method, field, package 741 742 if (srcType == SrcType.CLASS) { 743 // Contents for SuperClass 744 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 745 replaceVal = commonStmts + "\n" + anno; 746 String superClassContents = srcType.getTemplate() 747 .replace("#CN", SUPERCLASS) 748 .replace("#REPLACE", replaceVal); 749 750 // Contents for SubClass that extends SuperClass 751 replaceVal = expectedVals; 752 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 753 .replace("#CN", className) 754 .replace("#SN", SUPERCLASS) 755 .replace("#REPLACE", replaceVal); 756 757 contents = superClassContents + subClassContents; 758 srcFileObj = Helper.getFile(className, contents); 759 files = Arrays.asList(srcFileObj); 760 } 761 return files; 762 } 763 }, 764 ContainerOnSuperSingleOnSub_Inherited_Legacy( 765 "@ExpectedBase(value=Foo.class, " 766 + "getAnnotationVal = \"@Foo(value=0)\", " 767 + "getAnnotationsVals = {" 768 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " 769 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 770 + "getDeclAnnoVal = \"@Foo(value=0)\"," 771 + "getAnnosArgs = {\"@Foo(value=0)\"}," 772 + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", 773 "@ExpectedContainer(value=FooContainer.class, " 774 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 775 + "getAnnotationsVals = {" 776 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " 777 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 778 + "getDeclAnnoVal = \"NULL\"," 779 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 780 + "getDeclAnnosArgs = {})") { 781 782 @Override 783 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 784 String className) { 785 String anno = ""; 786 String replaceVal = ""; 787 String contents = ""; 788 JavaFileObject srcFileObj = null; 789 Iterable<? extends JavaFileObject> files = null; 790 791 String expectedVals = "\n" + getExpectedBase() + "\n" 792 + getExpectedContainer() + "\n"; 793 StringBuilder commonStmts = getCommonStmts(false); 794 795 /* 796 Sample testSrc: 797 @Retention(RetentionPolicy.RUNTIME) 798 @Inherited 799 @interface Foo {int value() default Integer.MAX_VALUE;} 800 801 @Retention(RetentionPolicy.RUNTIME) 802 @Inherited 803 @interface FooContainer { 804 Foo[] value(); 805 } 806 807 @FooContainer(value = {@Foo(1), @Foo(2)}) 808 class SuperClass { } 809 810 @ExpectedBase 811 @ExpectedContainer 812 @Foo(0) 813 class SubClass extends SuperClass {} 814 */ 815 // @Inherited only works for classes, no switch cases for 816 // method, field, package 817 818 if (srcType == SrcType.CLASS) { 819 // Contents for SuperClass 820 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 821 replaceVal = commonStmts + "\n" + anno; 822 String superClassContents = srcType.getTemplate() 823 .replace("#CN", SUPERCLASS) 824 .replace("#REPLACE", replaceVal); 825 826 // Contents for SubClass that extends SuperClass 827 anno = Helper.ContentVars.BASEANNO.getVal(); 828 replaceVal = expectedVals + "\n" + anno; 829 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 830 .replace("#CN", className) 831 .replace("#SN", SUPERCLASS) 832 .replace("#REPLACE", replaceVal); 833 834 contents = superClassContents + subClassContents; 835 srcFileObj = Helper.getFile(className, contents); 836 files = Arrays.asList(srcFileObj); 837 } 838 return files; 839 } 840 }, 841 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 842 // fail with ordering issues 843 ContainerAndSingleOnSuperSingleOnSub_Inherited_Legacy( 844 "@ExpectedBase(value=Foo.class, " 845 + "getAnnotationVal = \"@Foo(value=0)\", " 846 + "getAnnotationsVals = {" 847 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " 848 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 849 + "getDeclAnnoVal = \"@Foo(value=0)\"," 850 + "getAnnosArgs = {\"@Foo(value=0)\"}," 851 + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", 852 "@ExpectedContainer(value=FooContainer.class, " 853 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 854 + "getAnnotationsVals = {" 855 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " 856 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 857 + "getDeclAnnoVal = \"NULL\"," 858 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 859 + "getDeclAnnosArgs = {})") { 860 861 @Override 862 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 863 String className) { 864 String anno = ""; 865 String replaceVal = ""; 866 String contents = ""; 867 JavaFileObject srcFileObj = null; 868 Iterable<? extends JavaFileObject> files = null; 869 870 String expectedVals = "\n" + getExpectedBase() + "\n" 871 + getExpectedContainer() + "\n"; 872 StringBuilder commonStmts = getCommonStmts(false); 873 874 /* 875 Sample testSrc: 876 @Retention(RetentionPolicy.RUNTIME) 877 @Inherited 878 @interface Foo {int value() default Integer.MAX_VALUE;} 879 880 @Retention(RetentionPolicy.RUNTIME) 881 @Inherited 882 @interface FooContainer { 883 Foo[] value(); 884 } 885 886 @FooContainer(value = {@Foo(1), @Foo(2)}) @Foo(3) 887 class SuperClass { } 888 889 @ExpectedBase 890 @ExpectedContainer 891 @Foo(0) 892 class SubClass extends SuperClass {} 893 */ 894 // @Inherited only works for classes, no switch cases for 895 // method, field, package 896 897 if (srcType == SrcType.CLASS) { 898 // Contents for SuperClass 899 anno = Helper.ContentVars.LEGACYCONTAINER.getVal() 900 + "@Foo(3)"; 901 replaceVal = commonStmts + "\n" + anno; 902 String superClassContents = srcType.getTemplate() 903 .replace("#CN", SUPERCLASS) 904 .replace("#REPLACE", replaceVal); 905 906 // Contents for SubClass that extends SuperClass 907 anno = Helper.ContentVars.BASEANNO.getVal(); 908 replaceVal = expectedVals + "\n" + anno; 909 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 910 .replace("#CN", className).replace("#SN", SUPERCLASS) 911 .replace("#REPLACE", replaceVal); 912 913 contents = superClassContents + subClassContents; 914 srcFileObj = Helper.getFile(className, contents); 915 files = Arrays.asList(srcFileObj); 916 } 917 return files; 918 } 919 }, 920 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 921 // fail with ordering issues 922 SingleOnSuperContainerOnSub_Inherited_Legacy( 923 "@ExpectedBase(value=Foo.class, " 924 + "getAnnotationVal = \"@Foo(value=0)\", " 925 + "getAnnotationsVals = {" 926 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 927 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 928 + "getDeclAnnoVal = \"NULL\"," 929 + "getAnnosArgs = {\"@Foo(value=0)\"}," 930 + "getDeclAnnosArgs = {})", 931 "@ExpectedContainer(value=FooContainer.class, " 932 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 933 + "getAnnotationsVals = {" 934 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 935 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 936 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 937 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 938 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { 939 940 @Override 941 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 942 String className) { 943 String anno = ""; 944 String replaceVal = ""; 945 String contents = ""; 946 947 JavaFileObject srcFileObj = null; 948 Iterable<? extends JavaFileObject> files = null; 949 950 String expectedVals = "\n" + getExpectedBase() + "\n" 951 + getExpectedContainer() + "\n"; 952 StringBuilder commonStmts = getCommonStmts(false); 953 954 /* 955 Sample testSrc: 956 @Retention(RetentionPolicy.RUNTIME) 957 @Inherited 958 @interface Foo {int value() default Integer.MAX_VALUE;} 959 960 @Retention(RetentionPolicy.RUNTIME) 961 @Inherited 962 @interface FooContainer { 963 Foo[] value(); 964 } 965 966 @Foo(0) 967 class SuperClass { } 968 969 @ExpectedBase 970 @ExpectedContainer 971 @FooContainer(value = {@Foo(1), @Foo(2)}) 972 class SubClass extends SuperClass {} 973 */ 974 975 if (srcType == SrcType.CLASS) { 976 //Contents for SuperClass 977 anno = Helper.ContentVars.BASEANNO.getVal(); 978 replaceVal = commonStmts + "\n" + anno; 979 String superClassContents = srcType.getTemplate() 980 .replace("#CN", SUPERCLASS) 981 .replace("#REPLACE", replaceVal); 982 983 //Contents for SubClass that extends SuperClass 984 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 985 replaceVal = expectedVals + "\n" + anno; 986 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 987 .replace("#CN", className).replace("#SN", SUPERCLASS) 988 .replace("#REPLACE", replaceVal); 989 990 contents = superClassContents + subClassContents; 991 srcFileObj = Helper.getFile(className, contents); 992 files = Arrays.asList(srcFileObj); 993 } 994 return files; 995 } 996 }, 997 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 998 // fail with ordering issues 999 SingleOnSuperContainerAndSingleOnSub_Inherited_Legacy( 1000 "@ExpectedBase(value=Foo.class, " 1001 + "getAnnotationVal = \"@Foo(value=3)\", " 1002 + "getAnnotationsVals = {" 1003 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " 1004 + "getDeclAnnosVals = {" 1005 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," 1006 + "getDeclAnnoVal = \"@Foo(value=3)\"," 1007 + "getAnnosArgs = {\"@Foo(value=3)\"}," 1008 + "getDeclAnnosArgs = {\"@Foo(value=3)\"})", 1009 "@ExpectedContainer(value=FooContainer.class, " 1010 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1011 + "getAnnotationsVals = {" 1012 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " 1013 + "getDeclAnnosVals = {" 1014 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," 1015 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1016 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1017 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { 1018 1019 @Override 1020 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1021 String className) { 1022 String anno = ""; 1023 String replaceVal = ""; 1024 String contents = ""; 1025 1026 JavaFileObject srcFileObj = null; 1027 Iterable<? extends JavaFileObject> files = null; 1028 1029 String expectedVals = "\n" + getExpectedBase() + "\n" 1030 + getExpectedContainer() + "\n"; 1031 StringBuilder commonStmts = getCommonStmts(false); 1032 1033 /* 1034 Sample testSrc: 1035 @Retention(RetentionPolicy.RUNTIME) 1036 @Inherited 1037 @interface Foo {int value() default Integer.MAX_VALUE;} 1038 1039 @Retention(RetentionPolicy.RUNTIME) 1040 @Inherited 1041 @interface FooContainer { 1042 Foo[] value(); 1043 } 1044 1045 @Foo(0) 1046 class SuperClass { } 1047 1048 @ExpectedBase 1049 @ExpectedContainer 1050 @FooContainer(value = {@Foo(1), @Foo(2)}) @Foo(3) 1051 class SubClass extends SuperClass {} 1052 */ 1053 1054 if (srcType == SrcType.CLASS) { 1055 //Contents for SuperClass 1056 anno = Helper.ContentVars.BASEANNO.getVal(); 1057 replaceVal = commonStmts + "\n" + anno; 1058 String superClassContents = srcType.getTemplate() 1059 .replace("#CN", SUPERCLASS) 1060 .replace("#REPLACE", replaceVal); 1061 1062 //Contents for SubClass that extends SuperClass 1063 anno = Helper.ContentVars.LEGACYCONTAINER.getVal() 1064 + "@Foo(3)"; 1065 replaceVal = expectedVals + "\n" + anno; 1066 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1067 .replace("#CN", className).replace("#SN", SUPERCLASS) 1068 .replace("#REPLACE", replaceVal); 1069 1070 contents = superClassContents + subClassContents; 1071 srcFileObj = Helper.getFile(className, contents); 1072 files = Arrays.asList(srcFileObj); 1073 } 1074 return files; 1075 } 1076 }, 1077 BasicRepeatable( 1078 "@ExpectedBase(value=Foo.class, " 1079 + "getAnnotationVal = \"NULL\", " 1080 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\" }, " 1081 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1082 + "getDeclAnnoVal = \"NULL\"," 1083 + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}," 1084 + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"})", 1085 "@ExpectedContainer(value=FooContainer.class, " 1086 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1087 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1088 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1089 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1090 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1091 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { 1092 1093 @Override 1094 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1095 String className) { 1096 String anno = ""; 1097 String replaceVal = ""; 1098 String testSrc = ""; 1099 String pkgInfoContents = ""; 1100 String contents = ""; 1101 1102 JavaFileObject pkgFileObj = null; 1103 JavaFileObject srcFileObj = null; 1104 Iterable<? extends JavaFileObject> files = null; 1105 1106 String expectedVals = "\n" + getExpectedBase() + "\n" 1107 + getExpectedContainer() + "\n"; 1108 StringBuilder commonStmts = new StringBuilder(); 1109 1110 anno = Helper.ContentVars.REPEATABLEANNO.getVal(); 1111 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 1112 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 1113 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 1114 .append(Helper.ContentVars.REPEATABLE.getVal()) 1115 .append(Helper.ContentVars.BASE.getVal()) 1116 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 1117 .append(Helper.ContentVars.CONTAINER.getVal()); 1118 switch (srcType) { 1119 case PACKAGE: 1120 /* 1121 Sample package-info.java 1122 @ExpectedBase 1123 @ExpectedContainer 1124 @Foo(1) @Foo(2) 1125 package testpkg; 1126 1127 @Retention(RetentionPolicy.RUNTIME) 1128 @Repeatable(FooContainer.class) 1129 @interface Foo {int value() default Integer.MAX_VALUE;} 1130 1131 @Retention(RetentionPolicy.RUNTIME) 1132 @interface FooContainer { 1133 Foo[] value(); 1134 } 1135 1136 Sample testSrc: 1137 package testpkg; 1138 class A {} 1139 */ 1140 testSrc = srcType.getTemplate().replace("#CN", className); 1141 contents = testSrc; 1142 srcFileObj = Helper.getFile(className, contents); 1143 1144 replaceVal = expectedVals + "\n" + anno; 1145 pkgInfoContents = SrcType.PKGINFO.getTemplate() 1146 .replace("#REPLACE1", replaceVal) 1147 .replace("#REPLACE2", commonStmts); 1148 pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents); 1149 files = Arrays.asList(pkgFileObj, srcFileObj); 1150 break; 1151 default: 1152 /* 1153 Sample testSrc for class: 1154 @Retention(RetentionPolicy.RUNTIME) 1155 @Repeatable(FooContainer.class) 1156 @interface Foo {int value() default Integer.MAX_VALUE;} 1157 1158 @Retention(RetentionPolicy.RUNTIME) 1159 @interface FooContainer { 1160 Foo[] value(); 1161 } 1162 1163 @ExpectedBase 1164 @ExpectedContainer 1165 @Foo(1) @Foo(2) 1166 class A { } 1167 */ 1168 replaceVal = expectedVals + anno; 1169 testSrc = srcType.getTemplate().replace("#CN", className) 1170 .replace("#REPLACE", replaceVal); 1171 contents = commonStmts + testSrc; 1172 srcFileObj = Helper.getFile(className, contents); 1173 files = Arrays.asList(srcFileObj); 1174 } 1175 return files; 1176 } 1177 }, 1178 BasicContainerRepeatable( 1179 "@ExpectedBase(value=Foo.class, " 1180 + "getAnnotationVal = \"NULL\", " 1181 + "getAnnotationsVals = {" 1182 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1183 + "getDeclAnnosVals = {" 1184 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1185 + "getDeclAnnoVal = \"NULL\"," 1186 + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}," 1187 + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"})", 1188 "@ExpectedContainer(value=FooContainer.class, " 1189 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1190 + "getAnnotationsVals = {" 1191 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1192 + "getDeclAnnosVals = {" 1193 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1194 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1195 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1196 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { 1197 1198 @Override 1199 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1200 String className) { 1201 String anno = ""; 1202 String replaceVal = ""; 1203 String testSrc = ""; 1204 String pkgInfoContents = ""; 1205 String contents = ""; 1206 1207 JavaFileObject pkgFileObj = null; 1208 JavaFileObject srcFileObj = null; 1209 Iterable<? extends JavaFileObject> files = null; 1210 1211 String expectedVals = "\n" + getExpectedBase() + "\n" 1212 + getExpectedContainer() + "\n"; 1213 StringBuilder commonStmts = new StringBuilder(); 1214 1215 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 1216 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 1217 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 1218 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 1219 .append(Helper.ContentVars.REPEATABLE.getVal()) 1220 .append(Helper.ContentVars.BASE.getVal()) 1221 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 1222 .append(Helper.ContentVars.CONTAINER.getVal()); 1223 switch (srcType) { 1224 case PACKAGE: 1225 /* 1226 Sample package-info.java 1227 @ExpectedBase 1228 @ExpectedContainer 1229 @FooContainer(value = {@Foo(1), @Foo(2)}) 1230 package testpkg; 1231 1232 @Retention(RetentionPolicy.RUNTIME) 1233 @Repeatable(FooContainer.class) 1234 @interface Foo {int value() default Integer.MAX_VALUE;} 1235 1236 @Retention(RetentionPolicy.RUNTIME) 1237 @interface FooContainer { 1238 Foo[] value(); 1239 } 1240 1241 Sample testSrc: 1242 package testpkg; 1243 class A {} 1244 */ 1245 testSrc = srcType.getTemplate().replace("#CN", className); 1246 contents = testSrc; 1247 srcFileObj = Helper.getFile(className, contents); 1248 1249 replaceVal = expectedVals + "\n" + anno; 1250 pkgInfoContents = SrcType.PKGINFO.getTemplate() 1251 .replace("#REPLACE1", replaceVal) 1252 .replace("#REPLACE2", commonStmts); 1253 pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents); 1254 files = Arrays.asList(pkgFileObj, srcFileObj); 1255 break; 1256 default: 1257 /* 1258 Sample testSrc for class: 1259 @Retention(RetentionPolicy.RUNTIME) 1260 @Repeatable(FooContainer.class) 1261 @interface Foo {int value() default Integer.MAX_VALUE;} 1262 1263 @Retention(RetentionPolicy.RUNTIME) 1264 @interface FooContainer { 1265 Foo[] value(); 1266 } 1267 1268 @ExpectedBase 1269 @ExpectedContainer 1270 @FooContainer(value = {@Foo(1), @Foo(2)}) 1271 class A { } 1272 */ 1273 replaceVal = expectedVals + anno; 1274 testSrc = srcType.getTemplate().replace("#CN", className) 1275 .replace("#REPLACE", replaceVal); 1276 contents = commonStmts + testSrc; 1277 srcFileObj = Helper.getFile(className, contents); 1278 files = Arrays.asList(srcFileObj); 1279 } 1280 return files; 1281 } 1282 }, 1283 BasicContainerRepeatable_Inherited( 1284 "@ExpectedBase(value=Foo.class, " 1285 + "getAnnotationVal = \"NULL\", " 1286 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1287 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " 1288 + "getDeclAnnoVal = \"NULL\", " 1289 + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}, " 1290 + "getDeclAnnosArgs = {})", 1291 "@ExpectedContainer(value=FooContainer.class, " 1292 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1293 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1294 + "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, " 1295 + "getDeclAnnoVal = \"NULL\", " 1296 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1297 + "getDeclAnnosArgs = {})") { 1298 1299 @Override 1300 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1301 String className) { 1302 String anno = ""; 1303 String replaceVal = ""; 1304 String contents = ""; 1305 JavaFileObject srcFileObj = null; 1306 Iterable<? extends JavaFileObject> files = null; 1307 1308 String expectedVals = "\n" + getExpectedBase() + "\n" 1309 + getExpectedContainer() + "\n"; 1310 StringBuilder commonStmts = getCommonStmts(true); 1311 /* 1312 Sample testSrc: 1313 @Retention(RetentionPolicy.RUNTIME) 1314 @Inherited 1315 @Repeatable(FooContainer.class) 1316 @interface Foo {int value() default Integer.MAX_VALUE;} 1317 1318 @Retention(RetentionPolicy.RUNTIME) 1319 @Inherited 1320 @interface FooContainer { 1321 Foo[] value(); 1322 } 1323 1324 @FooContainer(value = {@Foo(1), @Foo(2)}) 1325 class SuperClass { } 1326 1327 @ExpectedBase 1328 @ExpectedContainer 1329 class SubClass extends SuperClass { } 1330 */ 1331 // @Inherited only works for classes, no switch cases for 1332 // method, field, package 1333 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 1334 1335 if (srcType == SrcType.CLASS) { 1336 // Contents for SuperClass 1337 replaceVal = commonStmts + "\n" + anno; 1338 String superClassContents = srcType.getTemplate() 1339 .replace("#CN", SUPERCLASS) 1340 .replace("#REPLACE", replaceVal); 1341 1342 // Contents for SubClass that extends SuperClass 1343 replaceVal = expectedVals; 1344 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1345 .replace("#CN", className) 1346 .replace("#SN", SUPERCLASS) 1347 .replace("#REPLACE", replaceVal); 1348 1349 contents = superClassContents + subClassContents; 1350 srcFileObj = Helper.getFile(className, contents); 1351 files = Arrays.asList(srcFileObj); 1352 } 1353 return files; 1354 } 1355 }, 1356 RepeatableAnnoInherited( 1357 "@ExpectedBase(value=Foo.class, " 1358 + "getAnnotationVal = \"NULL\", " 1359 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1360 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " 1361 + // ignores inherited annotations 1362 "getDeclAnnoVal = \"NULL\", " 1363 + // ignores inherited 1364 "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}, " 1365 + "getDeclAnnosArgs = {})", // ignores inherited 1366 "@ExpectedContainer(value=FooContainer.class, " 1367 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1368 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1369 + "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, " 1370 + // ignores inherited annotations 1371 "getDeclAnnoVal = \"NULL\", " 1372 + // ignores inherited 1373 "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1374 + "getDeclAnnosArgs = {})") { // ignores inherited 1375 1376 @Override 1377 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1378 String className) { 1379 String anno = ""; 1380 String replaceVal = ""; 1381 String contents = ""; 1382 JavaFileObject srcFileObj = null; 1383 Iterable<? extends JavaFileObject> files = null; 1384 1385 String expectedVals = "\n" + getExpectedBase() + "\n" 1386 + getExpectedContainer() + "\n"; 1387 StringBuilder commonStmts = getCommonStmts(true); 1388 /* 1389 Sample testSrc: 1390 @Retention(RetentionPolicy.RUNTIME) 1391 @Inherited 1392 @Repeatable(FooContainer.class) 1393 @interface Foo {int value() default Integer.MAX_VALUE;} 1394 1395 @Retention(RetentionPolicy.RUNTIME) 1396 @Inherited 1397 @interface FooContainer { 1398 Foo[] value(); 1399 } 1400 1401 @Foo(1) @Foo(2) 1402 class SuperClass { } 1403 1404 @ExpectedBase 1405 @ExpectedContainer 1406 class SubClass extends SuperClass { } 1407 */ 1408 // @Inherited only works for classes, no switch cases for 1409 // method, field, package 1410 anno = Helper.ContentVars.REPEATABLEANNO.getVal(); 1411 1412 if (srcType == SrcType.CLASS) { 1413 // Contents for SuperClass 1414 replaceVal = commonStmts + "\n" + anno; 1415 String superClassContents = srcType.getTemplate() 1416 .replace("#CN", SUPERCLASS) 1417 .replace("#REPLACE", replaceVal); 1418 1419 // Contents for SubClass that extends SuperClass 1420 replaceVal = expectedVals; 1421 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1422 .replace("#CN", className) 1423 .replace("#SN", SUPERCLASS) 1424 .replace("#REPLACE", replaceVal); 1425 1426 contents = superClassContents + subClassContents; 1427 srcFileObj = Helper.getFile(className, contents); 1428 files = Arrays.asList(srcFileObj); 1429 } 1430 return files; 1431 } 1432 }, 1433 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 1434 // fail with ordering issues 1435 SingleAnnoWithContainer( 1436 "@ExpectedBase(value=Foo.class, " 1437 + "getAnnotationVal = \"@Foo(value=0)\", " 1438 + "getAnnotationsVals = {" 1439 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1440 + "getDeclAnnosVals = {" 1441 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1442 + "getDeclAnnoVal = \"@Foo(value=0)\"," 1443 + "getAnnosArgs = {\"@Foo(value=0)\", \"@Foo(value=1)\", \"@Foo(value=2)\"}," 1444 + "getDeclAnnosArgs = {\"@Foo(value=0)\", \"@Foo(value=1)\",\"@Foo(value=2)\"})", 1445 "@ExpectedContainer(value=FooContainer.class, " 1446 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1447 + "getAnnotationsVals = {" 1448 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1449 + "getDeclAnnosVals = {" 1450 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1451 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1452 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1453 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { 1454 1455 @Override 1456 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1457 String className) { 1458 String anno = ""; 1459 String replaceVal = ""; 1460 String testSrc = ""; 1461 String pkgInfoContents = ""; 1462 String contents = ""; 1463 1464 JavaFileObject pkgFileObj = null; 1465 JavaFileObject srcFileObj = null; 1466 Iterable<? extends JavaFileObject> files = null; 1467 1468 String expectedVals = "\n" + getExpectedBase() + "\n" 1469 + getExpectedContainer() + "\n"; 1470 StringBuilder commonStmts = new StringBuilder(); 1471 1472 anno = Helper.ContentVars.BASEANNO.getVal() + " " 1473 + Helper.ContentVars.LEGACYCONTAINER.getVal(); 1474 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 1475 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 1476 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 1477 .append(Helper.ContentVars.REPEATABLE.getVal()) 1478 .append(Helper.ContentVars.BASE.getVal()) 1479 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 1480 .append(Helper.ContentVars.CONTAINER.getVal()); 1481 switch (srcType) { 1482 case PACKAGE: 1483 /* 1484 Sample package-info.java 1485 @ExpectedBase 1486 @ExpectedContainer 1487 @Foo(0) @FooContainer(value = {@Foo(1), @Foo(2)}) 1488 package testpkg; 1489 1490 @Retention(RetentionPolicy.RUNTIME) 1491 @Repeatable(FooContainer.class) 1492 @interface Foo {int value() default Integer.MAX_VALUE;} 1493 1494 @Retention(RetentionPolicy.RUNTIME) 1495 @interface FooContainer { 1496 Foo[] value(); 1497 } 1498 1499 Sample testSrc: 1500 package testpkg; 1501 class A {} 1502 */ 1503 testSrc = srcType.getTemplate().replace("#CN", className); 1504 contents = testSrc; 1505 srcFileObj = Helper.getFile(className, contents); 1506 1507 replaceVal = expectedVals + "\n" + anno; 1508 pkgInfoContents = SrcType.PKGINFO.getTemplate() 1509 .replace("#REPLACE1", replaceVal) 1510 .replace("#REPLACE2", commonStmts); 1511 pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents); 1512 files = Arrays.asList(pkgFileObj, srcFileObj); 1513 break; 1514 default: 1515 /* 1516 Sample testSrc: 1517 @Retention(RetentionPolicy.RUNTIME) 1518 @Inherited 1519 @Repeatable(FooContainer.class) 1520 @interface Foo {int value() default Integer.MAX_VALUE;} 1521 1522 @Retention(RetentionPolicy.RUNTIME) 1523 @Inherited 1524 @interface FooContainer { 1525 Foo[] value(); 1526 } 1527 1528 @ExpectedBase 1529 @ExpectedContainer 1530 @Foo(0) @FooContainer(value = {@Foo(1), @Foo(2)}) 1531 class A { } 1532 */ 1533 replaceVal = expectedVals + anno; 1534 testSrc = srcType.getTemplate() 1535 .replace("#CN", className) 1536 .replace("#REPLACE", replaceVal); 1537 contents = commonStmts + testSrc; 1538 srcFileObj = Helper.getFile(className, contents); 1539 files = Arrays.asList(srcFileObj); 1540 } 1541 return files; 1542 } 1543 }, 1544 AnnoOnSuperAndSubClass_Inherited( 1545 "@ExpectedBase(value=Foo.class, " 1546 + "getAnnotationVal = \"@Foo(value=1)\", " 1547 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\" }, " 1548 + // override every annotation on superClass 1549 "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\"}, " 1550 + // ignores inherited annotations 1551 "getDeclAnnoVal = \"@Foo(value=1)\", " // ignores inherited 1552 + "getAnnosArgs = {\"@Foo(value=1)\"}, " 1553 + "getDeclAnnosArgs = { \"@Foo(value=1)\" })", // ignores inherited 1554 "@ExpectedContainer(value=FooContainer.class, " 1555 + "getAnnotationVal = \"NULL\", " 1556 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\" }, " 1557 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\"}, " 1558 + // ignores inherited annotations 1559 "getDeclAnnoVal = \"NULL\", " + // ignores inherited 1560 "getAnnosArgs = {}, " + "getDeclAnnosArgs = {})") { 1561 1562 @Override 1563 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1564 String className) { 1565 String anno = ""; 1566 String replaceVal = ""; 1567 String contents = ""; 1568 JavaFileObject srcFileObj = null; 1569 Iterable<? extends JavaFileObject> files = null; 1570 1571 String expectedVals = "\n" + getExpectedBase() + "\n" 1572 + getExpectedContainer() + "\n"; 1573 StringBuilder commonStmts = getCommonStmts(true); 1574 1575 /* 1576 Sample testSrc: 1577 @Retention(RetentionPolicy.RUNTIME) 1578 @Inherited 1579 @Repeatable(FooContainer.class) 1580 @interface Foo {int value() default Integer.MAX_VALUE;} 1581 1582 @Retention(RetentionPolicy.RUNTIME) 1583 @Inherited 1584 @interface FooContainer { 1585 Foo[] value(); 1586 } 1587 1588 @Foo(0) 1589 class SuperClass { } 1590 1591 @ExpectedBase 1592 @ExpectedContainer 1593 @Foo(1) 1594 class SubClass extends SuperClass { } 1595 */ 1596 // @Inherited only works for classes, no switch cases for 1597 // method, field, package 1598 1599 if (srcType == SrcType.CLASS) { 1600 // Contents for SuperClass 1601 anno = Helper.ContentVars.BASEANNO.getVal(); 1602 replaceVal = commonStmts + "\n" + anno; 1603 String superClassContents = srcType.getTemplate() 1604 .replace("#CN", SUPERCLASS) 1605 .replace("#REPLACE", replaceVal); 1606 1607 // Contents for SubClass that extends SuperClass 1608 replaceVal = expectedVals + "\n" + "@Foo(1)"; 1609 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1610 .replace("#CN", className) 1611 .replace("#SN", SUPERCLASS) 1612 .replace("#REPLACE", replaceVal); 1613 1614 contents = superClassContents + subClassContents; 1615 srcFileObj = Helper.getFile(className, contents); 1616 files = Arrays.asList(srcFileObj); 1617 } 1618 return files; 1619 } 1620 }, 1621 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 1622 // fail with ordering issues 1623 RepeatableOnSuperSingleOnSub_Inherited( 1624 "@ExpectedBase(value=Foo.class, " 1625 + "getAnnotationVal = \"@Foo(value=3)\", " 1626 + "getAnnotationsVals = {" 1627 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1628 + //override every annotation on superClass 1629 "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\"}, " 1630 + // ignores inherited annotations 1631 "getDeclAnnoVal = \"@Foo(value=3)\", " // ignores inherited 1632 + "getAnnosArgs = {\"@Foo(value=3)\"}, " 1633 + "getDeclAnnosArgs = { \"@Foo(value=3)\" })", // ignores inherited 1634 "@ExpectedContainer(value=FooContainer.class, " 1635 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1636 + "getAnnotationsVals = {" 1637 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1638 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\"}, " 1639 + // ignores inherited annotations 1640 "getDeclAnnoVal = \"NULL\", " 1641 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1642 + "getDeclAnnosArgs = {}) // ignores inherited ") { 1643 1644 @Override 1645 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1646 String className) { 1647 String anno = ""; 1648 String replaceVal = ""; 1649 String contents = ""; 1650 JavaFileObject srcFileObj = null; 1651 Iterable<? extends JavaFileObject> files = null; 1652 1653 String expectedVals = "\n" + getExpectedBase() + "\n" 1654 + getExpectedContainer() + "\n"; 1655 StringBuilder commonStmts = getCommonStmts(true); 1656 1657 /* 1658 Sample testSrc: 1659 @Retention(RetentionPolicy.RUNTIME) 1660 @Inherited 1661 @Repeatable(FooContainer.class) 1662 @interface Foo {int value() default Integer.MAX_VALUE;} 1663 1664 @Retention(RetentionPolicy.RUNTIME) 1665 @Inherited 1666 @interface FooContainer { 1667 Foo[] value(); 1668 } 1669 1670 @Foo(1) @Foo(2) 1671 class SuperClass { } 1672 1673 @ExpectedBase 1674 @ExpectedContainer 1675 @Foo(3) 1676 class SubClass extends SuperClass { } 1677 */ 1678 //@Inherited only works for classes, no switch cases for method, field, package 1679 if (srcType == SrcType.CLASS) { 1680 //Contents for SuperClass 1681 anno = Helper.ContentVars.REPEATABLEANNO.getVal(); 1682 replaceVal = commonStmts + "\n" + anno; 1683 String superClassContents = srcType.getTemplate() 1684 .replace("#CN", SUPERCLASS) 1685 .replace("#REPLACE", replaceVal); 1686 1687 //Contents for SubClass that extends SuperClass 1688 anno = "@Foo(3)"; 1689 replaceVal = expectedVals + "\n" + anno; 1690 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1691 .replace("#CN", className) 1692 .replace("#SN", SUPERCLASS) 1693 .replace("#REPLACE", replaceVal); 1694 contents = superClassContents + subClassContents; 1695 srcFileObj = Helper.getFile(className, contents); 1696 files = Arrays.asList(srcFileObj); 1697 } 1698 return files; 1699 } 1700 }, 1701 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 1702 // fail with ordering issues 1703 SingleOnSuperRepeatableOnSub_Inherited( 1704 "@ExpectedBase(value=Foo.class, " 1705 + "getAnnotationVal = \"@Foo(value=0)\", " 1706 + "getAnnotationsVals = {" 1707 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1708 + //override every annotation on superClass 1709 "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1710 + // ignores inherited annotations 1711 "getDeclAnnoVal = \"NULL\","// ignores inherited 1712 + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}, " 1713 + "getDeclAnnosArgs = { \"@Foo(value=1)\", \"@Foo(value=2)\"})", 1714 "@ExpectedContainer(value=FooContainer.class, " 1715 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1716 + "getAnnotationsVals = {" 1717 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1718 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1719 + // ignores inherited annotations 1720 "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", "// ignores inherited 1721 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1722 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { 1723 1724 @Override 1725 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1726 String className) { 1727 String anno = ""; 1728 String replaceVal = ""; 1729 String contents = ""; 1730 JavaFileObject srcFileObj = null; 1731 Iterable<? extends JavaFileObject> files = null; 1732 1733 String expectedVals = "\n" + getExpectedBase() + "\n" 1734 + getExpectedContainer() + "\n"; 1735 StringBuilder commonStmts = getCommonStmts(true); 1736 1737 /* 1738 Sample testSrc: 1739 @Retention(RetentionPolicy.RUNTIME) 1740 @Inherited 1741 @Repeatable(FooContainer.class) 1742 @interface Foo {int value() default Integer.MAX_VALUE;} 1743 1744 @Retention(RetentionPolicy.RUNTIME) 1745 @Inherited 1746 @interface FooContainer { 1747 Foo[] value(); 1748 } 1749 1750 @Foo(0) 1751 class SuperClass { } 1752 1753 @ExpectedBase 1754 @ExpectedContainer 1755 @Foo(1) @Foo(2) 1756 class SubClass extends SuperClass { } 1757 */ 1758 //@Inherited only works for classes, no switch cases for method, field, package 1759 if (srcType == SrcType.CLASS) { 1760 //Contents for SuperClass 1761 anno = Helper.ContentVars.BASEANNO.getVal(); 1762 replaceVal = commonStmts + "\n" + anno; 1763 String superClassContents = srcType.getTemplate() 1764 .replace("#CN", SUPERCLASS) 1765 .replace("#REPLACE", replaceVal); 1766 1767 //Contents for SubClass that extends SuperClass 1768 anno = Helper.ContentVars.REPEATABLEANNO.getVal(); 1769 replaceVal = expectedVals + "\n" + anno; 1770 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1771 .replace("#CN", className) 1772 .replace("#SN", SUPERCLASS) 1773 .replace("#REPLACE", replaceVal); 1774 1775 contents = superClassContents + subClassContents; 1776 srcFileObj = Helper.getFile(className, contents); 1777 files = Arrays.asList(srcFileObj); 1778 } 1779 return files; 1780 } 1781 }, 1782 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 1783 // fail with ordering issues 1784 ContainerOnSuperSingleOnSub_Inherited( 1785 "@ExpectedBase(value=Foo.class, " 1786 + "getAnnotationVal = \"@Foo(value=0)\", " 1787 + "getAnnotationsVals = {" 1788 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1789 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 1790 + "getDeclAnnoVal = \"@Foo(value=0)\"," 1791 + "getAnnosArgs = {\"@Foo(value=0)\"}," 1792 + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", 1793 "@ExpectedContainer(value=FooContainer.class, " 1794 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1795 + "getAnnotationsVals = {" 1796 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1797 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 1798 + "getDeclAnnoVal = \"NULL\"," 1799 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1800 + "getDeclAnnosArgs = {})") { 1801 1802 @Override 1803 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1804 String className) { 1805 String anno = ""; 1806 String replaceVal = ""; 1807 String contents = ""; 1808 JavaFileObject srcFileObj = null; 1809 Iterable<? extends JavaFileObject> files = null; 1810 1811 String expectedVals = "\n" + getExpectedBase() + "\n" 1812 + getExpectedContainer() + "\n"; 1813 StringBuilder commonStmts = getCommonStmts(true); 1814 1815 /* 1816 Sample testSrc: 1817 @Retention(RetentionPolicy.RUNTIME) 1818 @Inherited 1819 @Repeatable(FooContainer.class) 1820 @interface Foo {int value() default Integer.MAX_VALUE;} 1821 1822 @Retention(RetentionPolicy.RUNTIME) 1823 @Inherited 1824 @interface FooContainer { 1825 Foo[] value(); 1826 } 1827 1828 @FooContainer(value = {@Foo(1), @Foo(2)}) 1829 class SuperClass { } 1830 1831 @ExpectedBase 1832 @ExpectedContainer 1833 @Foo(0) 1834 class SubClass extends SuperClass { } 1835 */ 1836 //@Inherited only works for classes, no switch cases for method, field, package 1837 if (srcType == SrcType.CLASS) { 1838 //Contents for SuperClass 1839 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 1840 replaceVal = commonStmts + "\n" + anno; 1841 String superClassContents = srcType.getTemplate() 1842 .replace("#CN", SUPERCLASS) 1843 .replace("#REPLACE", replaceVal); 1844 1845 //Contents for SubClass that extends SuperClass 1846 anno = Helper.ContentVars.BASEANNO.getVal(); 1847 replaceVal = expectedVals + "\n" + anno; 1848 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1849 .replace("#CN", className) 1850 .replace("#SN", SUPERCLASS) 1851 .replace("#REPLACE", replaceVal); 1852 1853 contents = superClassContents + subClassContents; 1854 srcFileObj = Helper.getFile(className, contents); 1855 files = Arrays.asList(srcFileObj); 1856 } 1857 return files; 1858 } 1859 }, 1860 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 1861 // fail with ordering issues 1862 SingleOnSuperContainerOnSub_Inherited( 1863 "@ExpectedBase(value=Foo.class, " 1864 + "getAnnotationVal = \"@Foo(value=0)\", " 1865 + "getAnnotationsVals = {" 1866 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1867 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1868 + "getDeclAnnoVal = \"NULL\"," 1869 + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}," 1870 + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"})", 1871 "@ExpectedContainer(value=FooContainer.class, " 1872 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1873 + "getAnnotationsVals = {" 1874 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 1875 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1876 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1877 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1878 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { 1879 1880 @Override 1881 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1882 String className) { 1883 String anno = ""; 1884 String replaceVal = ""; 1885 String contents = ""; 1886 JavaFileObject srcFileObj = null; 1887 Iterable<? extends JavaFileObject> files = null; 1888 1889 String expectedVals = "\n" + getExpectedBase() + "\n" 1890 + getExpectedContainer() + "\n"; 1891 StringBuilder commonStmts = getCommonStmts(true); 1892 1893 /* 1894 Sample testSrc: 1895 @Retention(RetentionPolicy.RUNTIME) 1896 @Inherited 1897 @Repeatable(FooContainer.class) 1898 @interface Foo {int value() default Integer.MAX_VALUE;} 1899 1900 @Retention(RetentionPolicy.RUNTIME) 1901 @Inherited 1902 @interface FooContainer { 1903 Foo[] value(); 1904 } 1905 1906 @Foo(0) 1907 class SuperClass { } 1908 1909 @ExpectedBase 1910 @ExpectedContainer 1911 @FooContainer(value = {@Foo(1), @Foo(2)}) 1912 class SubClass extends SuperClass { } 1913 */ 1914 //@Inherited only works for classes, no switch cases for method, field, package 1915 if (srcType == SrcType.CLASS) { 1916 //Contents for SuperClass 1917 anno = Helper.ContentVars.BASEANNO.getVal(); 1918 replaceVal = commonStmts + "\n" + anno; 1919 String superClassContents = srcType.getTemplate() 1920 .replace("#CN", SUPERCLASS) 1921 .replace("#REPLACE", replaceVal); 1922 1923 //Contents for SubClass that extends SuperClass 1924 anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); 1925 replaceVal = expectedVals + "\n" + anno; 1926 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 1927 .replace("#CN", className) 1928 .replace("#SN", SUPERCLASS) 1929 .replace("#REPLACE", replaceVal); 1930 1931 contents = superClassContents + subClassContents; 1932 srcFileObj = Helper.getFile(className, contents); 1933 files = Arrays.asList(srcFileObj); 1934 } 1935 return files; 1936 } 1937 }, 1938 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 1939 // fail with ordering issues 1940 SingleOnSuperContainerAndSingleOnSub_Inherited( 1941 "@ExpectedBase(value=Foo.class, " 1942 + "getAnnotationVal = \"@Foo(value=3)\", " 1943 + "getAnnotationsVals = {" 1944 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " 1945 + "getDeclAnnosVals = {" 1946 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," 1947 + "getDeclAnnoVal = \"@Foo(value=3)\"," 1948 + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\", \"@Foo(value=3)\"}," 1949 + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\", \"@Foo(value=3)\"})", 1950 "@ExpectedContainer(value=FooContainer.class, " 1951 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 1952 + "getAnnotationsVals = {" 1953 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " 1954 + "getDeclAnnosVals = {" 1955 + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," 1956 + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," 1957 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 1958 + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { 1959 1960 @Override 1961 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 1962 String className) { 1963 String anno = ""; 1964 String replaceVal = ""; 1965 String contents = ""; 1966 JavaFileObject srcFileObj = null; 1967 Iterable<? extends JavaFileObject> files = null; 1968 String expectedVals = "\n" + getExpectedBase() + "\n" 1969 + getExpectedContainer() + "\n"; 1970 StringBuilder commonStmts = getCommonStmts(true); 1971 1972 /* 1973 Sample testSrc: 1974 @Retention(RetentionPolicy.RUNTIME) 1975 @Inherited 1976 @interface Foo {int value() default Integer.MAX_VALUE;} 1977 1978 @Retention(RetentionPolicy.RUNTIME) 1979 @Inherited 1980 @Repeatable(FooContainer.class) 1981 @interface FooContainer { 1982 Foo[] value(); 1983 } 1984 1985 @Foo(0) 1986 class SuperClass { } 1987 1988 @ExpectedBase 1989 @ExpectedContainer 1990 @FooContainer(value = {@Foo(1), @Foo(2)}) @Foo(3) 1991 class SubClass extends SuperClass {} 1992 */ 1993 1994 if (srcType == SrcType.CLASS) { 1995 //Contents for SuperClass 1996 anno = Helper.ContentVars.BASEANNO.getVal(); 1997 replaceVal = commonStmts + "\n" + anno; 1998 String superClassContents = srcType.getTemplate() 1999 .replace("#CN", SUPERCLASS) 2000 .replace("#REPLACE", replaceVal); 2001 2002 //Contents for SubClass that extends SuperClass 2003 anno = Helper.ContentVars.LEGACYCONTAINER.getVal() 2004 + "@Foo(3)"; 2005 replaceVal = expectedVals + "\n" + anno; 2006 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 2007 .replace("#CN", className) 2008 .replace("#SN", SUPERCLASS) 2009 .replace("#REPLACE", replaceVal); 2010 2011 contents = superClassContents + subClassContents; 2012 srcFileObj = Helper.getFile(className, contents); 2013 files = Arrays.asList(srcFileObj); 2014 } 2015 return files; 2016 } 2017 }, 2018 // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest 2019 // fail with ordering issues 2020 ContainerAndSingleOnSuperSingleOnSub_Inherited( 2021 "@ExpectedBase(value=Foo.class, " 2022 + "getAnnotationVal = \"@Foo(value=0)\", " 2023 + "getAnnotationsVals = {" 2024 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 2025 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 2026 + "getDeclAnnoVal = \"@Foo(value=0)\"," 2027 + "getAnnosArgs = {\"@Foo(value=0)\"}," 2028 + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", 2029 "@ExpectedContainer(value=FooContainer.class, " 2030 + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " 2031 + "getAnnotationsVals = {" 2032 + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " 2033 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," 2034 + "getDeclAnnoVal = \"NULL\"," 2035 + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," 2036 + "getDeclAnnosArgs = {})") { 2037 2038 @Override 2039 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 2040 String className) { 2041 String anno = ""; 2042 String replaceVal = ""; 2043 String contents = ""; 2044 JavaFileObject srcFileObj = null; 2045 Iterable<? extends JavaFileObject> files = null; 2046 2047 String expectedVals = "\n" + getExpectedBase() + "\n" 2048 + getExpectedContainer() + "\n"; 2049 StringBuilder commonStmts = getCommonStmts(true); 2050 2051 /* 2052 Sample testSrc: 2053 @Retention(RetentionPolicy.RUNTIME) 2054 @Inherited 2055 @Repeatable(FooContainer.class) 2056 @interface Foo {int value() default Integer.MAX_VALUE;} 2057 2058 @Retention(RetentionPolicy.RUNTIME) 2059 @Inherited 2060 @interface FooContainer { 2061 Foo[] value(); 2062 } 2063 2064 @FooContainer(value = {@Foo(1), @Foo(2)}) 2065 @Foo(3) 2066 class SuperClass { } 2067 2068 @ExpectedBase 2069 @ExpectedContainer 2070 @Foo(0) 2071 class SubClass extends SuperClass { } 2072 */ 2073 2074 //@Inherited only works for classes, no switch cases for method, field, package 2075 if (srcType == SrcType.CLASS) { 2076 //Contents for SuperClass 2077 anno = Helper.ContentVars.LEGACYCONTAINER.getVal() 2078 + "@Foo(3)" ; 2079 replaceVal = commonStmts + "\n" + anno; 2080 String superClassContents = srcType.getTemplate() 2081 .replace("#CN", SUPERCLASS) 2082 .replace("#REPLACE", replaceVal); 2083 2084 //Contents for SubClass that extends SuperClass 2085 anno = Helper.ContentVars.BASEANNO.getVal(); 2086 replaceVal = expectedVals + "\n" + anno; 2087 String subClassContents = SrcType.CLASSEXTENDS.getTemplate() 2088 .replace("#CN", className) 2089 .replace("#SN", SUPERCLASS) 2090 .replace("#REPLACE", replaceVal); 2091 2092 contents = superClassContents + subClassContents; 2093 srcFileObj = Helper.getFile(className, contents); 2094 files = Arrays.asList(srcFileObj); 2095 } 2096 return files; 2097 } 2098 }; 2099 2100 private String expectedBase, expectedContainer; 2101 2102 private TestCase(String expectedBase, String expectedContainer) { 2103 this.expectedBase = expectedBase; 2104 this.expectedContainer = expectedContainer; 2105 } 2106 2107 public String getExpectedBase() { 2108 return expectedBase; 2109 } 2110 2111 public String getExpectedContainer() { 2112 return expectedContainer; 2113 } 2114 2115 // Each enum element should override this method 2116 public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, 2117 String className) { 2118 return null; 2119 } 2120 } 2121 2122 /* 2123 * Each srctype has its template defined used for test src generation 2124 * Primary src types: class, method, field, package define 2125 * getExpectedBase() and getExpectedContainer() 2126 */ 2127 enum SrcType { 2128 2129 CLASS("\n#REPLACE\nclass #CN { } ") { 2130 2131 @Override 2132 public ExpectedBase getExpectedBase(Class<?> c) { 2133 return c.getAnnotation(ExpectedBase.class); 2134 } 2135 2136 @Override 2137 public ExpectedContainer getExpectedContainer(Class<?> c) { 2138 return c.getAnnotation(ExpectedContainer.class); 2139 } 2140 }, 2141 METHOD("class #CN {\n" + " " + "#REPLACE\n" + " void " 2142 + TESTMETHOD + "() {} \n" + "}\n") { 2143 2144 @Override 2145 public ExpectedBase getExpectedBase(Class<?> c) { 2146 ExpectedBase ret = null; 2147 try { 2148 ret = c.getDeclaredMethod(TESTMETHOD).getAnnotation( 2149 ExpectedBase.class); 2150 } catch (NoSuchMethodException nme) { 2151 error("Could not get " + TESTMETHOD + " for className " 2152 + c.getName() + " Exception:\n" + nme); 2153 } 2154 return ret; 2155 } 2156 2157 @Override 2158 public ExpectedContainer getExpectedContainer(Class<?> c) { 2159 ExpectedContainer ret = null; 2160 try { 2161 ret = c.getDeclaredMethod(TESTMETHOD).getAnnotation( 2162 ExpectedContainer.class); 2163 } catch (NoSuchMethodException nme) { 2164 error("Could not get " + TESTMETHOD + " for className " 2165 + c.getName() + " Exception:\n" + nme); 2166 } 2167 return ret; 2168 2169 } 2170 }, 2171 FIELD("class #CN {\n" + " " + "#REPLACE\n" + " int " + TESTFIELD 2172 + " = 0; \n" + "}\n") { 2173 2174 @Override 2175 public ExpectedBase getExpectedBase(Class<?> c) { 2176 ExpectedBase ret = null; 2177 try { 2178 ret = c.getDeclaredField(TESTFIELD).getAnnotation( 2179 ExpectedBase.class); 2180 } catch (NoSuchFieldException nme) { 2181 error("Could not get " + TESTFIELD + " for className " 2182 + c.getName() + " Exception:\n" + nme); 2183 } 2184 return ret; 2185 } 2186 2187 @Override 2188 public ExpectedContainer getExpectedContainer(Class<?> c) { 2189 ExpectedContainer ret = null; 2190 try { 2191 ret = c.getDeclaredField(TESTFIELD).getAnnotation( 2192 ExpectedContainer.class); 2193 } catch (NoSuchFieldException nme) { 2194 error("Could not get " + TESTFIELD + " for className " 2195 + c.getName() + " Exception:\n" + nme); 2196 } 2197 return ret; 2198 2199 } 2200 }, 2201 PACKAGE("package " + TESTPKG + "; \n" + "class #CN {}") { 2202 2203 @Override 2204 public ExpectedBase getExpectedBase(Class<?> c) { 2205 return c.getPackage().getAnnotation(ExpectedBase.class); 2206 } 2207 2208 @Override 2209 public ExpectedContainer getExpectedContainer(Class<?> c) { 2210 return c.getPackage().getAnnotation(ExpectedContainer.class); 2211 } 2212 }, 2213 PKGINFO("#REPLACE1\npackage " + TESTPKG + "; \n" + "#REPLACE2"), 2214 INTERFACE("#REPLACE\ninterface #IN { } "), 2215 INTERFACEIMPL("#REPLACE\nclass #CN implements #IN {}"), 2216 CLASSEXTENDS("#REPLACE\nclass #CN extends #SN {}"); 2217 String template; 2218 2219 private SrcType(String template) { 2220 this.template = template; 2221 } 2222 2223 public String getTemplate() { 2224 return template; 2225 } 2226 2227 // Elements should override 2228 public ExpectedBase getExpectedBase(Class<?> c) { 2229 return null; 2230 } 2231 2232 public ExpectedContainer getExpectedContainer(Class<?> c) { 2233 return null; 2234 } 2235 2236 /* 2237 * Returns only primary src types ; 2238 */ 2239 public static SrcType[] getSrcTypes() { 2240 return new SrcType[]{CLASS, PACKAGE, METHOD, FIELD}; 2241 } 2242 } 2243 2244 /* 2245 * Each enum constant is one of the 6 methods from AnnotatedElement interface 2246 * that needs to be tested. 2247 * Each enum constant overrides these 4 methods: 2248 * - getActualAnnoBase(SrcType srcType, Class<?> c) 2249 * - getActualAnnoContainer(SrcType srcType, Class<?> c) 2250 * - getExpectedAnnoBase(SrcType srcType, Class<?> c) 2251 * - getExpectedAnnoContainer(SrcType srcType, Class<?> c) 2252 */ 2253 enum TestMethod { 2254 2255 GET_ANNO("getAnnotation") { 2256 2257 @Override 2258 public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { 2259 Annotation[] actualAnno = new Annotation[1]; 2260 switch (srcType) { 2261 case CLASS: 2262 actualAnno[0] = c.getAnnotation(srcType.getExpectedBase(c).value()); 2263 break; 2264 case PACKAGE: 2265 actualAnno[0] = c.getPackage().getAnnotation( 2266 srcType.getExpectedBase(c).value()); 2267 break; 2268 case METHOD: 2269 try { 2270 actualAnno[0] = c.getDeclaredMethod(TESTMETHOD).getAnnotation( 2271 srcType.getExpectedBase(c).value()); 2272 } catch (NoSuchMethodException nme) { 2273 error("Could not get " + TESTMETHOD 2274 + " for className = " + c.getName() 2275 + "Exception = " + nme); 2276 } 2277 break; 2278 case FIELD: 2279 try { 2280 actualAnno[0] = c.getDeclaredField(TESTFIELD).getAnnotation( 2281 srcType.getExpectedBase(c).value()); 2282 } catch (NoSuchFieldException nfe) { 2283 error("Could not get " + TESTFIELD 2284 + " for className = " + c.getName() 2285 + "Exception = " + nfe); 2286 } 2287 break; 2288 } 2289 return actualAnno; 2290 } 2291 2292 @Override 2293 public Annotation[] getActualAnnoContainer(SrcType srcType, 2294 Class<?> c) { 2295 Annotation[] actualAnno = new Annotation[1]; 2296 switch (srcType) { 2297 case CLASS: 2298 actualAnno[0] = c.getAnnotation(srcType.getExpectedContainer(c).value()); 2299 break; 2300 case PACKAGE: 2301 actualAnno[0] = c.getPackage().getAnnotation( 2302 srcType.getExpectedContainer(c).value()); 2303 break; 2304 case METHOD: 2305 try { 2306 actualAnno[0] = c.getDeclaredMethod(TESTMETHOD).getAnnotation( 2307 srcType.getExpectedContainer(c).value()); 2308 } catch (NoSuchMethodException nme) { 2309 error("Could not get " + TESTMETHOD 2310 + " for className = " + c.getName() 2311 + "Exception = " + nme); 2312 } 2313 break; 2314 case FIELD: 2315 try { 2316 actualAnno[0] = c.getDeclaredField(TESTFIELD).getAnnotation( 2317 srcType.getExpectedContainer(c).value()); 2318 } catch (NoSuchFieldException nfe) { 2319 error("Could not get " + TESTFIELD 2320 + " for className = " + c.getName() 2321 + "Exception = " + nfe); 2322 } 2323 break; 2324 } 2325 return actualAnno; 2326 } 2327 2328 @Override 2329 public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { 2330 String[] expAnno = {srcType.getExpectedBase(c).getAnnotationVal()}; 2331 return expAnno; 2332 } 2333 2334 @Override 2335 public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { 2336 String[] expAnno = {srcType.getExpectedContainer(c).getAnnotationVal()}; 2337 return expAnno; 2338 } 2339 }, 2340 GET_ANNOS("getAnnotations") { 2341 2342 @Override 2343 public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { 2344 Annotation[] actualAnnos = null; 2345 switch (srcType) { 2346 case CLASS: 2347 actualAnnos = c.getAnnotations(); 2348 break; 2349 case PACKAGE: 2350 actualAnnos = c.getPackage().getAnnotations(); 2351 break; 2352 case METHOD: 2353 try { 2354 actualAnnos = c.getDeclaredMethod(TESTMETHOD).getAnnotations(); 2355 } catch (NoSuchMethodException nme) { 2356 error("Could not get " + TESTMETHOD 2357 + " for className = " + c.getName() 2358 + "Exception = " + nme); 2359 } 2360 break; 2361 case FIELD: 2362 try { 2363 actualAnnos = c.getDeclaredField(TESTFIELD).getAnnotations(); 2364 } catch (NoSuchFieldException nfe) { 2365 error("Could not get " + TESTFIELD 2366 + " for className = " + c.getName() 2367 + "Exception = " + nfe); 2368 } 2369 break; 2370 } 2371 return actualAnnos; 2372 } 2373 2374 @Override 2375 public Annotation[] getActualAnnoContainer(SrcType srcType, 2376 Class<?> c) { 2377 Annotation[] actualAnnos = null; 2378 switch (srcType) { 2379 case CLASS: 2380 actualAnnos = c.getAnnotations(); 2381 break; 2382 case PACKAGE: 2383 actualAnnos = c.getPackage().getAnnotations(); 2384 break; 2385 case METHOD: 2386 try { 2387 actualAnnos = c.getDeclaredMethod(TESTMETHOD).getAnnotations(); 2388 } catch (NoSuchMethodException nme) { 2389 error("Could not get " + TESTMETHOD 2390 + " for className = " + c.getName() 2391 + "Exception = " + nme); 2392 } 2393 break; 2394 case FIELD: 2395 try { 2396 actualAnnos = c.getDeclaredField(TESTFIELD).getAnnotations(); 2397 } catch (NoSuchFieldException nfe) { 2398 error("Could not get " + TESTFIELD 2399 + " for className = " + c.getName() 2400 + "Exception = " + nfe); 2401 } 2402 break; 2403 } 2404 return actualAnnos; 2405 } 2406 2407 @Override 2408 public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { 2409 return srcType.getExpectedBase(c).getAnnotationsVals(); 2410 } 2411 2412 @Override 2413 public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { 2414 return srcType.getExpectedContainer(c).getAnnotationsVals(); 2415 } 2416 }, 2417 GET_DECL_ANNOS("getDeclaredAnnotations") { 2418 2419 @Override 2420 public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { 2421 Annotation[] actualDeclAnnos = null; 2422 switch (srcType) { 2423 case CLASS: 2424 actualDeclAnnos = c.getDeclaredAnnotations(); 2425 break; 2426 case PACKAGE: 2427 actualDeclAnnos = c.getPackage().getDeclaredAnnotations(); 2428 break; 2429 case METHOD: 2430 try { 2431 actualDeclAnnos = c.getDeclaredMethod(TESTMETHOD) 2432 .getDeclaredAnnotations(); 2433 } catch (NoSuchMethodException nme) { 2434 error("Could not get " + TESTMETHOD 2435 + " for className = " + c.getName() 2436 + "Exception = " + nme); 2437 } 2438 break; 2439 case FIELD: 2440 try { 2441 actualDeclAnnos = c.getDeclaredField(TESTFIELD) 2442 .getDeclaredAnnotations(); 2443 } catch (NoSuchFieldException nfe) { 2444 error("Could not get " + TESTFIELD 2445 + " for className = " + c.getName() 2446 + "Exception = " + nfe); 2447 } 2448 break; 2449 } 2450 return actualDeclAnnos; 2451 } 2452 2453 @Override 2454 public Annotation[] getActualAnnoContainer(SrcType srcType, 2455 Class<?> c) { 2456 Annotation[] actualDeclAnnos = null; 2457 switch (srcType) { 2458 case CLASS: 2459 actualDeclAnnos = c.getDeclaredAnnotations(); 2460 break; 2461 case PACKAGE: 2462 actualDeclAnnos = c.getPackage().getDeclaredAnnotations(); 2463 break; 2464 case METHOD: 2465 try { 2466 actualDeclAnnos = c.getDeclaredMethod(TESTMETHOD) 2467 .getDeclaredAnnotations(); 2468 } catch (NoSuchMethodException nme) { 2469 error("Could not get " + TESTMETHOD 2470 + " for className = " + c.getName() 2471 + "Exception = " + nme); 2472 } 2473 break; 2474 case FIELD: 2475 try { 2476 actualDeclAnnos = c.getDeclaredField(TESTFIELD) 2477 .getDeclaredAnnotations(); 2478 } catch (NoSuchFieldException nfe) { 2479 error("Could not get " + TESTFIELD 2480 + " for className = " + c.getName() 2481 + "Exception = " + nfe); 2482 } 2483 break; 2484 } 2485 return actualDeclAnnos; 2486 } 2487 2488 @Override 2489 public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { 2490 return srcType.getExpectedBase(c).getDeclAnnosVals(); 2491 } 2492 2493 @Override 2494 public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { 2495 return srcType.getExpectedContainer(c).getDeclAnnosVals(); 2496 } 2497 }, 2498 GET_DECL_ANNO("getDeclaredAnnotation") { 2499 2500 @Override 2501 public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { 2502 Annotation[] actualDeclAnno = new Annotation[1]; 2503 switch (srcType) { 2504 case CLASS: 2505 actualDeclAnno[0] = c.getDeclaredAnnotation( 2506 srcType.getExpectedBase(c).value()); 2507 break; 2508 case PACKAGE: 2509 actualDeclAnno[0] = c.getPackage().getDeclaredAnnotation( 2510 srcType.getExpectedBase(c).value()); 2511 break; 2512 case METHOD: 2513 try { 2514 actualDeclAnno[0] = c.getDeclaredMethod(TESTMETHOD) 2515 .getDeclaredAnnotation( 2516 srcType.getExpectedBase(c).value()); 2517 } catch (NoSuchMethodException nme) { 2518 error("Could not get " + TESTMETHOD 2519 + " for className = " + c.getName() 2520 + "Exception = " + nme); 2521 } 2522 break; 2523 case FIELD: 2524 try { 2525 actualDeclAnno[0] = c.getDeclaredField(TESTFIELD) 2526 .getDeclaredAnnotation( 2527 srcType.getExpectedBase(c).value()); 2528 } catch (NoSuchFieldException nfe) { 2529 error("Could not get " + TESTFIELD 2530 + " for className = " + c.getName() 2531 + "Exception = " + nfe); 2532 } 2533 break; 2534 } 2535 return actualDeclAnno; 2536 } 2537 2538 @Override 2539 public Annotation[] getActualAnnoContainer(SrcType srcType, 2540 Class<?> c) { 2541 Annotation[] actualDeclAnno = new Annotation[1]; 2542 switch (srcType) { 2543 case CLASS: 2544 actualDeclAnno[0] = c.getDeclaredAnnotation( 2545 srcType.getExpectedContainer(c).value()); 2546 break; 2547 case PACKAGE: 2548 actualDeclAnno[0] = c.getPackage().getDeclaredAnnotation( 2549 srcType.getExpectedContainer(c).value()); 2550 break; 2551 case METHOD: 2552 try { 2553 actualDeclAnno[0] = c.getDeclaredMethod(TESTMETHOD) 2554 .getDeclaredAnnotation( 2555 srcType.getExpectedContainer(c).value()); 2556 } catch (NoSuchMethodException nme) { 2557 error("Could not get " + TESTMETHOD 2558 + " for className = " + c.getName() 2559 + "Exception = " + nme); 2560 } 2561 break; 2562 case FIELD: 2563 try { 2564 actualDeclAnno[0] = c.getDeclaredField(TESTFIELD) 2565 .getDeclaredAnnotation( 2566 srcType.getExpectedContainer(c).value()); 2567 } catch (NoSuchFieldException nfe) { 2568 error("Could not get " + TESTFIELD 2569 + " for className = " + c.getName() 2570 + "Exception = " + nfe); 2571 } 2572 break; 2573 } 2574 return actualDeclAnno; 2575 } 2576 2577 @Override 2578 public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { 2579 String[] expAnno = {srcType.getExpectedBase(c).getDeclAnnoVal()}; 2580 return expAnno; 2581 } 2582 2583 @Override 2584 public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { 2585 String[] expAnno = {srcType.getExpectedContainer(c).getDeclAnnoVal()}; 2586 return expAnno; 2587 } 2588 }, // new 2589 GET_ANNOS_ARG("getAnnotationsArg") { 2590 2591 @Override 2592 public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { 2593 Annotation[] actualAnnoArgs = null; 2594 switch (srcType) { 2595 case CLASS: 2596 actualAnnoArgs = c.getAnnotationsByType(srcType.getExpectedBase(c).value()); 2597 break; 2598 case PACKAGE: 2599 actualAnnoArgs = c.getPackage().getAnnotationsByType( 2600 srcType.getExpectedBase(c).value()); 2601 break; 2602 case METHOD: 2603 try { 2604 actualAnnoArgs = c.getDeclaredMethod(TESTMETHOD) 2605 .getAnnotationsByType( 2606 srcType.getExpectedBase(c).value()); 2607 } catch (NoSuchMethodException nme) { 2608 error("Could not get " + TESTMETHOD 2609 + " for className = " + c.getName() 2610 + "Exception = " + nme); 2611 } 2612 break; 2613 case FIELD: 2614 try { 2615 actualAnnoArgs = c.getDeclaredField(TESTFIELD) 2616 .getAnnotationsByType( 2617 srcType.getExpectedBase(c).value()); 2618 } catch (NoSuchFieldException nfe) { 2619 error("Could not get " + TESTFIELD 2620 + " for className = " + c.getName() 2621 + "Exception = " + nfe); 2622 } 2623 break; 2624 } 2625 return actualAnnoArgs; 2626 } 2627 2628 @Override 2629 public Annotation[] getActualAnnoContainer(SrcType srcType, 2630 Class<?> c) { 2631 Annotation[] actualAnnoArgs = null; 2632 switch (srcType) { 2633 case CLASS: 2634 actualAnnoArgs = c.getAnnotationsByType(srcType.getExpectedContainer(c).value()); 2635 break; 2636 case PACKAGE: 2637 actualAnnoArgs = c.getPackage().getAnnotationsByType( 2638 srcType.getExpectedContainer(c).value()); 2639 break; 2640 case METHOD: 2641 try { 2642 actualAnnoArgs = c.getDeclaredMethod(TESTMETHOD) 2643 .getAnnotationsByType( 2644 srcType.getExpectedContainer(c).value()); 2645 } catch (NoSuchMethodException nme) { 2646 error("Could not get " + TESTMETHOD 2647 + " for className = " + c.getName() 2648 + "Exception = " + nme); 2649 } 2650 break; 2651 case FIELD: 2652 try { 2653 actualAnnoArgs = c.getDeclaredField(TESTFIELD) 2654 .getAnnotationsByType( 2655 srcType.getExpectedContainer(c).value()); 2656 } catch (NoSuchFieldException nfe) { 2657 error("Could not get " + TESTFIELD 2658 + " for className = " + c.getName() 2659 + "Exception = " + nfe); 2660 } 2661 break; 2662 } 2663 return actualAnnoArgs; 2664 } 2665 2666 @Override 2667 public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { 2668 return srcType.getExpectedBase(c).getAnnosArgs(); 2669 } 2670 2671 @Override 2672 public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { 2673 return srcType.getExpectedContainer(c).getAnnosArgs(); 2674 } 2675 }, // new 2676 GET_DECL_ANNOS_ARG("getDeclAnnosArg") { 2677 2678 @Override 2679 public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { 2680 Annotation[] actualDeclAnnosArgs = null; 2681 switch (srcType) { 2682 case CLASS: 2683 actualDeclAnnosArgs = c.getDeclaredAnnotationsByType( 2684 srcType.getExpectedBase(c).value()); 2685 break; 2686 case PACKAGE: 2687 actualDeclAnnosArgs = c.getPackage().getDeclaredAnnotationsByType( 2688 srcType.getExpectedBase(c).value()); 2689 break; 2690 case METHOD: 2691 try { 2692 actualDeclAnnosArgs = c.getDeclaredMethod(TESTMETHOD) 2693 .getDeclaredAnnotationsByType( 2694 srcType.getExpectedBase(c).value()); 2695 } catch (NoSuchMethodException nme) { 2696 error("Could not get " + TESTMETHOD 2697 + " for className = " + c.getName() 2698 + "Exception = " + nme); 2699 } 2700 break; 2701 case FIELD: 2702 try { 2703 actualDeclAnnosArgs = c.getDeclaredField(TESTFIELD) 2704 .getDeclaredAnnotationsByType( 2705 srcType.getExpectedBase(c).value()); 2706 } catch (NoSuchFieldException nfe) { 2707 error("Could not get " + TESTFIELD 2708 + " for className = " + c.getName() 2709 + "Exception = " + nfe); 2710 } 2711 break; 2712 } 2713 return actualDeclAnnosArgs; 2714 } 2715 2716 @Override 2717 public Annotation[] getActualAnnoContainer(SrcType srcType, 2718 Class<?> c) { 2719 Annotation[] actualDeclAnnosArgs = null; 2720 switch (srcType) { 2721 case CLASS: 2722 actualDeclAnnosArgs = c.getDeclaredAnnotationsByType( 2723 srcType.getExpectedContainer(c).value()); 2724 break; 2725 case PACKAGE: 2726 actualDeclAnnosArgs = c.getPackage().getDeclaredAnnotationsByType( 2727 srcType.getExpectedContainer(c).value()); 2728 break; 2729 case METHOD: 2730 try { 2731 actualDeclAnnosArgs = c.getDeclaredMethod(TESTMETHOD) 2732 .getDeclaredAnnotationsByType( 2733 srcType.getExpectedContainer(c).value()); 2734 } catch (NoSuchMethodException nme) { 2735 error("Could not get " + TESTMETHOD 2736 + " for className = " + c.getName() 2737 + "Exception = " + nme); 2738 } 2739 break; 2740 case FIELD: 2741 try { 2742 actualDeclAnnosArgs = c.getDeclaredField(TESTFIELD) 2743 .getDeclaredAnnotationsByType( 2744 srcType.getExpectedContainer(c).value()); 2745 } catch (NoSuchFieldException nfe) { 2746 error("Could not get " + TESTFIELD 2747 + " for className = " + c.getName() 2748 + "Exception = " + nfe); 2749 } 2750 break; 2751 } 2752 return actualDeclAnnosArgs; 2753 } 2754 2755 @Override 2756 public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { 2757 return srcType.getExpectedBase(c).getDeclAnnosArgs(); 2758 } 2759 2760 @Override 2761 public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { 2762 return srcType.getExpectedContainer(c).getDeclAnnosArgs(); 2763 } 2764 }; // new 2765 String name; 2766 2767 private TestMethod(String name) { 2768 this.name = name; 2769 } 2770 2771 public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { 2772 return null; 2773 } 2774 2775 public Annotation[] getActualAnnoContainer(SrcType srcType, Class<?> c) { 2776 return null; 2777 } 2778 2779 public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { 2780 return null; 2781 } 2782 2783 public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { 2784 return null; 2785 } 2786 } 2787 2788 /* 2789 * For a given srcType and class object, compare expectedBase and actualBase 2790 * annotations as well as expectedContainer and actualContainer annotations. 2791 * 2792 * Return true if both comparisons are true else return false. 2793 * 2794 */ 2795 protected static void checkAnnoValues(SrcType srcType, Class<?> c) { 2796 2797 // Load @ExpectedBase and @ExpectedContainer 2798 ExpectedBase eb = srcType.getExpectedBase(c); 2799 ExpectedContainer ec = srcType.getExpectedContainer(c); 2800 if (eb == null) { 2801 error("Did not find ExpectedBase Annotation, Test will exit"); 2802 throw new RuntimeException(); 2803 } 2804 if (ec == null) { 2805 error("Did not find ExpectedContainer Annotation, Test will exit"); 2806 throw new RuntimeException(); 2807 } 2808 2809 for (TestMethod testMethod : TestMethod.values()) { 2810 debugPrint("---------------------------------------------"); 2811 debugPrint("Test method = " + testMethod); 2812 boolean isBasePass = true; 2813 boolean isConPass = true; 2814 // ExpectedBase = Annotation, no annotation is defined, skip comparison 2815 if (!eb.value().getSimpleName().equalsIgnoreCase("Annotation")) { 2816 isBasePass = compareAnnotations( 2817 testMethod.getActualAnnoBase(srcType, c), 2818 testMethod.getExpectedAnnoBase(srcType, c)); 2819 } 2820 2821 // ExpectedContainer = Annotation, no annotation is defined, skip comparison 2822 if (!ec.value().getSimpleName().equalsIgnoreCase("Annotation")) { 2823 isConPass = compareAnnotations( 2824 testMethod.getActualAnnoContainer(srcType, c), 2825 testMethod.getExpectedAnnoContainer(srcType, c)); 2826 } 2827 if (isBasePass && isConPass) { 2828 debugPrint("Testcase passed for " + testMethod + 2829 " for className = " + c.getName()); 2830 } else { 2831 debugPrint("Testcase failed for " + testMethod + 2832 " for className = " + c.getName()); 2833 } 2834 } 2835 } 2836 2837 // Annotation comparison: Length should be same and all expected values 2838 // should be present in actualAnno[]. 2839 private static boolean compareAnnotations(Annotation[] actualAnnos, 2840 String[] expectedAnnos) { 2841 boolean compOrder = false; 2842 2843 // Length is different 2844 if (actualAnnos.length != expectedAnnos.length) { 2845 error("Length not same, Actual length = " + actualAnnos.length 2846 + " Expected length = " + expectedAnnos.length); 2847 printArrContents(actualAnnos); 2848 printArrContents(expectedAnnos); 2849 return false; 2850 } else { 2851 int i = 0; 2852 // Length is same and 0 2853 if (actualAnnos.length == 0) { 2854 // Expected/actual lengths already checked for 2855 // equality; no more checks do to 2856 return true; 2857 } 2858 // Expected annotation should be NULL 2859 if (actualAnnos[0] == null) { 2860 if (expectedAnnos[0].equals("NULL")) { 2861 debugPrint("Arr values are NULL as expected"); 2862 return true; 2863 } else { 2864 error("Array values are not NULL"); 2865 printArrContents(actualAnnos); 2866 printArrContents(expectedAnnos); 2867 return false; 2868 } 2869 } 2870 // Lengths are same, compare array contents 2871 String[] actualArr = new String[actualAnnos.length]; 2872 for (Annotation a : actualAnnos) { 2873 if (a.annotationType().getSimpleName().contains("Expected")) 2874 actualArr[i++] = a.annotationType().getSimpleName(); 2875 else if (a.annotationType().getName().contains(TESTPKG)) { 2876 String replaced = a.toString().replaceAll(Pattern.quote("testpkg."),""); 2877 actualArr[i++] = replaced; 2878 } else 2879 actualArr[i++] = a.toString(); 2880 } 2881 List<String> actualList = new ArrayList<String>(Arrays.asList(actualArr)); 2882 List<String> expectedList = new ArrayList<String>(Arrays.asList(expectedAnnos)); 2883 if (!actualList.containsAll(expectedList)) { 2884 error("Array values are not same"); 2885 printArrContents(actualAnnos); 2886 printArrContents(expectedAnnos); 2887 return false; 2888 } else { 2889 debugPrint("Arr values are same as expected"); 2890 if (CHECKORDERING) { 2891 debugPrint("Checking if annotation ordering is as expected.."); 2892 compOrder = compareOrdering(actualList, expectedList); 2893 if (compOrder) 2894 debugPrint("Arr values ordering is as expected"); 2895 else 2896 error("Arr values ordering is not as expected! actual values: " 2897 + actualList + " expected values: " + expectedList); 2898 } else 2899 compOrder = true; 2900 } 2901 } 2902 return compOrder; 2903 } 2904 2905 // Annotation ordering comparison 2906 private static boolean compareOrdering(List<String> actualList, List<String> expectedList) { 2907 boolean order = true; 2908 // Discarding Expected* annotations before comparison of ordering 2909 actualList = iterateList(actualList); 2910 expectedList = iterateList(expectedList); 2911 // Length is different 2912 if (actualList.size() != expectedList.size()) { 2913 error("Length not same, Actual list length = " + actualList.size() 2914 + " Expected list length = " + expectedList.size()); 2915 return false; 2916 } else { 2917 if (actualList.isEmpty() && expectedList.isEmpty()) { 2918 return true; 2919 } 2920 boolean tmp = true; 2921 for (int i = 0; i < actualList.size(); i++) { 2922 // Checking ordering 2923 if (order) { 2924 if (!actualList.get(i).equals(expectedList.get(i))) { 2925 tmp = false; 2926 debugPrint("Odering is false"); 2927 debugPrint("actualList values: " + actualList 2928 + " expectedList values: " + expectedList); 2929 } 2930 } 2931 } 2932 order = tmp; 2933 } 2934 return order; 2935 } 2936 2937 private static List<String> iterateList(List<String> list) { 2938 Iterator<String> iter = list.iterator(); 2939 while (iter.hasNext()) { 2940 String anno = iter.next(); 2941 if (anno.contains("Expected")) { 2942 iter.remove(); 2943 } 2944 } 2945 return list; 2946 } 2947 2948 private static void printArrContents(Annotation[] actualAnnos) { 2949 System.out.print("Actual Arr Values: "); 2950 for (Annotation a : actualAnnos) { 2951 if (a != null && a.annotationType() != null) { 2952 System.out.print("[" + a.toString() + "]"); 2953 } else { 2954 System.out.println("[null]"); 2955 } 2956 } 2957 System.out.println(); 2958 } 2959 2960 private static void printArrContents(String[] expectedAnnos) { 2961 System.out.print("Expected Arr Values: "); 2962 for (String s : expectedAnnos) { 2963 System.out.print("[" + s + "]"); 2964 } 2965 System.out.println(); 2966 } 2967 2968 private ClassLoader getLoader() { 2969 return getClass().getClassLoader(); 2970 } 2971 2972 private static Class<?> loadClass(String className, ClassLoader parentClassLoader, File... destDirs) { 2973 try { 2974 List<URL> list = new ArrayList<>(); 2975 for (File f : destDirs) { 2976 list.add(new URL("file:" + f.toString().replace("\\", "/") + "/")); 2977 } 2978 return Class.forName(className, true, new URLClassLoader( 2979 list.toArray(new URL[list.size()]), parentClassLoader)); 2980 } catch (ClassNotFoundException | MalformedURLException e) { 2981 throw new RuntimeException("Error loading class " + className, e); 2982 } 2983 } 2984 2985 private static void printTestSrc(Iterable<? extends JavaFileObject> files) { 2986 for (JavaFileObject f : files) { 2987 System.out.println("Test file " + f.getName() + ":"); 2988 try { 2989 System.out.println("" + f.getCharContent(true)); 2990 } catch (IOException e) { 2991 throw new RuntimeException( 2992 "Exception when printing test src contents for class " + 2993 f.getName(), e); 2994 } 2995 } 2996 2997 } 2998 2999 public static StringBuilder getCommonStmts(boolean isRepeatable) { 3000 StringBuilder sb = new StringBuilder(); 3001 3002 sb.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) 3003 .append(Helper.ContentVars.IMPORTSTMTS.getVal()) 3004 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 3005 .append(Helper.ContentVars.INHERITED.getVal()); 3006 if(isRepeatable) { 3007 sb.append(Helper.ContentVars.REPEATABLE.getVal()); 3008 } 3009 sb.append(Helper.ContentVars.BASE.getVal()) 3010 .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) 3011 .append(Helper.ContentVars.INHERITED.getVal()) 3012 .append(Helper.ContentVars.CONTAINER.getVal()); 3013 return sb; 3014 } 3015 3016 private static int getNumErrors() { 3017 return errors; 3018 } 3019 3020 private static void error(String msg) { 3021 System.out.println("error: " + msg); 3022 errors++; 3023 } 3024 3025 private static void debugPrint(String string) { 3026 if(DEBUG) 3027 System.out.println(string); 3028 } 3029} 3030