1 /* 2 * Copyright 2003-2004 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 20 * CA 95054 USA or visit www.sun.com if you need additional information or 21 * have any questions. 22 */ 23 24 /* 25 * @test 26 * @bug 4906359 4963461 4965058 4965039 4986770 27 * @summary Unit test for annotation reading 28 * @author Josh Bloch 29 * @compile -source 1.5 UnitTest.java 30 * @run main UnitTest 31 */ 32 33 import static java.lang.annotation.RetentionPolicy.RUNTIME; 34 35 import java.lang.annotation.*; 36 import java.util.*; 37 import java.lang.reflect.*; 38 import java.io.*; 39 40 public class UnitTest { 41 private static final Class[] X = new Class[0]; 42 private static final Class[] Y = { int.class }; 43 44 static int numTests = 0; 45 46 public static void main(String[] args) throws Exception { 47 48 // *** TESTS ON ANNOTATED METHODS *** 49 50 // MULTIMEMBER SCALAR TYPES ON METHOD 51 checkScalarTypes(UnitTest.class.getMethod("scalarTypesMethod", X)); 52 checkScalarTypesOverrideDefault(UnitTest.class.getMethod("scalarTypesOverrideDefaultMethod", X)); 53 checkScalarTypesAcceptDefault(UnitTest.class.getMethod("scalarTypesAcceptDefaultMethod", X)); 54 55 // MULTIMEMBER ARRAY TYPES ON METHOD 56 checkArrayTypes0(UnitTest.class.getMethod("emptyArrayTypesMethod", X)); 57 checkArrayTypes1(UnitTest.class.getMethod("singleElementArrayTypesMethod", X)); 58 checkArrayTypes2(UnitTest.class.getMethod("twoElementArrayTypesMethod", X)); 59 checkArrayTypesAcceptDefault(UnitTest.class.getMethod("arrayTypesAcceptDefaultMethod", X)); 60 checkArrayTypesOverrideDefault(UnitTest.class.getMethod("arrayTypesOverrideDefaultMethod", X)); 61 62 // MARKER TYPE ON METHOD 63 checkMarker(UnitTest.class.getMethod("markerMethod", X)); 64 65 // SINGLE-MEMBER SCALAR TYPES ON METHOD 66 checkSingleMemberByte(UnitTest.class.getMethod("SingleMemberByte", X)); 67 checkSingleMemberShort(UnitTest.class.getMethod("SingleMemberShort", X)); 68 checkSingleMemberInt(UnitTest.class.getMethod("SingleMemberInt", X)); 69 checkSingleMemberLong(UnitTest.class.getMethod("SingleMemberLong", X)); 70 checkSingleMemberChar(UnitTest.class.getMethod("SingleMemberChar", X)); 71 checkSingleMemberFloat(UnitTest.class.getMethod("SingleMemberFloat", X)); 72 checkSingleMemberDouble(UnitTest.class.getMethod("SingleMemberDouble", X)); 73 checkSingleMemberBoolean(UnitTest.class.getMethod("SingleMemberBoolean", X)); 74 checkSingleMemberString(UnitTest.class.getMethod("SingleMemberString", X)); 75 checkSingleMemberClass(UnitTest.class.getMethod("SingleMemberClass", X)); 76 checkSingleMemberEnum(UnitTest.class.getMethod("SingleMemberEnum", X)); 77 78 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON METHOD 79 checkSingleMemberByteOvrdDef(UnitTest.class.getMethod("SingleMemberByteOvrdDef", X)); 80 checkSingleMemberShortOvrdDef(UnitTest.class.getMethod("SingleMemberShortOvrdDef", X)); 81 checkSingleMemberIntOvrdDef(UnitTest.class.getMethod("SingleMemberIntOvrdDef", X)); 82 checkSingleMemberLongOvrdDef(UnitTest.class.getMethod("SingleMemberLongOvrdDef", X)); 83 checkSingleMemberCharOvrdDef(UnitTest.class.getMethod("SingleMemberCharOvrdDef", X)); 84 checkSingleMemberFloatOvrdDef(UnitTest.class.getMethod("SingleMemberFloatOvrdDef", X)); 85 checkSingleMemberDoubleOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleOvrdDef", X)); 86 checkSingleMemberBooleanOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanOvrdDef", X)); 87 checkSingleMemberStringOvrdDef(UnitTest.class.getMethod("SingleMemberStringOvrdDef", X)); 88 checkSingleMemberClassOvrdDef(UnitTest.class.getMethod("SingleMemberClassOvrdDef", X)); 89 checkSingleMemberEnumOvrdDef(UnitTest.class.getMethod("SingleMemberEnumOvrdDef", X)); 90 91 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON METHOD 92 checkSingleMemberByteAcceptDef(UnitTest.class.getMethod("SingleMemberByteAcceptDef", X)); 93 checkSingleMemberShortAcceptDef(UnitTest.class.getMethod("SingleMemberShortAcceptDef", X)); 94 checkSingleMemberIntAcceptDef(UnitTest.class.getMethod("SingleMemberIntAcceptDef", X)); 95 checkSingleMemberLongAcceptDef(UnitTest.class.getMethod("SingleMemberLongAcceptDef", X)); 96 checkSingleMemberCharAcceptDef(UnitTest.class.getMethod("SingleMemberCharAcceptDef", X)); 97 checkSingleMemberFloatAcceptDef(UnitTest.class.getMethod("SingleMemberFloatAcceptDef", X)); 98 checkSingleMemberDoubleAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleAcceptDef", X)); 99 checkSingleMemberBooleanAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanAcceptDef", X)); 100 checkSingleMemberStringAcceptDef(UnitTest.class.getMethod("SingleMemberStringAcceptDef", X)); 101 checkSingleMemberClassAcceptDef(UnitTest.class.getMethod("SingleMemberClassAcceptDef", X)); 102 checkSingleMemberEnumAcceptDef(UnitTest.class.getMethod("SingleMemberEnumAcceptDef", X)); 103 104 // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON METHOD 105 checkSingleMemberByteArrEmpty(UnitTest.class.getMethod("SingleMemberByteArrEmpty", X)); 106 checkSingleMemberShortArrEmpty(UnitTest.class.getMethod("SingleMemberShortArrEmpty", X)); 107 checkSingleMemberIntArrEmpty(UnitTest.class.getMethod("SingleMemberIntArrEmpty", X)); 108 checkSingleMemberLongArrEmpty(UnitTest.class.getMethod("SingleMemberLongArrEmpty", X)); 109 checkSingleMemberCharArrEmpty(UnitTest.class.getMethod("SingleMemberCharArrEmpty", X)); 110 checkSingleMemberFloatArrEmpty(UnitTest.class.getMethod("SingleMemberFloatArrEmpty", X)); 111 checkSingleMemberDoubleArrEmpty(UnitTest.class.getMethod("SingleMemberDoubleArrEmpty", X)); 112 checkSingleMemberBooleanArrEmpty(UnitTest.class.getMethod("SingleMemberBooleanArrEmpty", X)); 113 checkSingleMemberStringArrEmpty(UnitTest.class.getMethod("SingleMemberStringArrEmpty", X)); 114 checkSingleMemberClassArrEmpty(UnitTest.class.getMethod("SingleMemberClassArrEmpty", X)); 115 checkSingleMemberEnumArrEmpty(UnitTest.class.getMethod("SingleMemberEnumArrEmpty", X)); 116 117 // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON METHOD 118 checkSingleMemberByteArrOne(UnitTest.class.getMethod("SingleMemberByteArrOne", X)); 119 checkSingleMemberShortArrOne(UnitTest.class.getMethod("SingleMemberShortArrOne", X)); 120 checkSingleMemberIntArrOne(UnitTest.class.getMethod("SingleMemberIntArrOne", X)); 121 checkSingleMemberLongArrOne(UnitTest.class.getMethod("SingleMemberLongArrOne", X)); 122 checkSingleMemberCharArrOne(UnitTest.class.getMethod("SingleMemberCharArrOne", X)); 123 checkSingleMemberFloatArrOne(UnitTest.class.getMethod("SingleMemberFloatArrOne", X)); 124 checkSingleMemberDoubleArrOne(UnitTest.class.getMethod("SingleMemberDoubleArrOne", X)); 125 checkSingleMemberBooleanArrOne(UnitTest.class.getMethod("SingleMemberBooleanArrOne", X)); 126 checkSingleMemberStringArrOne(UnitTest.class.getMethod("SingleMemberStringArrOne", X)); 127 checkSingleMemberClassArrOne(UnitTest.class.getMethod("SingleMemberClassArrOne", X)); 128 checkSingleMemberEnumArrOne(UnitTest.class.getMethod("SingleMemberEnumArrOne", X)); 129 130 // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON METHOD 131 checkSingleMemberByteArrTwo(UnitTest.class.getMethod("SingleMemberByteArrTwo", X)); 132 checkSingleMemberShortArrTwo(UnitTest.class.getMethod("SingleMemberShortArrTwo", X)); 133 checkSingleMemberIntArrTwo(UnitTest.class.getMethod("SingleMemberIntArrTwo", X)); 134 checkSingleMemberLongArrTwo(UnitTest.class.getMethod("SingleMemberLongArrTwo", X)); 135 checkSingleMemberCharArrTwo(UnitTest.class.getMethod("SingleMemberCharArrTwo", X)); 136 checkSingleMemberFloatArrTwo(UnitTest.class.getMethod("SingleMemberFloatArrTwo", X)); 137 checkSingleMemberDoubleArrTwo(UnitTest.class.getMethod("SingleMemberDoubleArrTwo", X)); 138 checkSingleMemberBooleanArrTwo(UnitTest.class.getMethod("SingleMemberBooleanArrTwo", X)); 139 checkSingleMemberStringArrTwo(UnitTest.class.getMethod("SingleMemberStringArrTwo", X)); 140 checkSingleMemberClassArrTwo(UnitTest.class.getMethod("SingleMemberClassArrTwo", X)); 141 checkSingleMemberEnumArrTwo(UnitTest.class.getMethod("SingleMemberEnumArrTwo", X)); 142 143 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON METHOD 144 checkSingleMemberByteArrOvrdDef(UnitTest.class.getMethod("SingleMemberByteArrOvrdDef", X)); 145 checkSingleMemberShortArrOvrdDef(UnitTest.class.getMethod("SingleMemberShortArrOvrdDef", X)); 146 checkSingleMemberIntArrOvrdDef(UnitTest.class.getMethod("SingleMemberIntArrOvrdDef", X)); 147 checkSingleMemberLongArrOvrdDef(UnitTest.class.getMethod("SingleMemberLongArrOvrdDef", X)); 148 checkSingleMemberCharArrOvrdDef(UnitTest.class.getMethod("SingleMemberCharArrOvrdDef", X)); 149 checkSingleMemberFloatArrOvrdDef(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDef", X)); 150 checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDef", X)); 151 checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDef", X)); 152 checkSingleMemberStringArrOvrdDef(UnitTest.class.getMethod("SingleMemberStringArrOvrdDef", X)); 153 checkSingleMemberClassArrOvrdDef(UnitTest.class.getMethod("SingleMemberClassArrOvrdDef", X)); 154 checkSingleMemberEnumArrOvrdDef(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDef", X)); 155 156 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON METHOD 157 checkSingleMemberByteArrAcceptDef(UnitTest.class.getMethod("SingleMemberByteArrAcceptDef", X)); 158 checkSingleMemberShortArrAcceptDef(UnitTest.class.getMethod("SingleMemberShortArrAcceptDef", X)); 159 checkSingleMemberIntArrAcceptDef(UnitTest.class.getMethod("SingleMemberIntArrAcceptDef", X)); 160 checkSingleMemberLongArrAcceptDef(UnitTest.class.getMethod("SingleMemberLongArrAcceptDef", X)); 161 checkSingleMemberCharArrAcceptDef(UnitTest.class.getMethod("SingleMemberCharArrAcceptDef", X)); 162 checkSingleMemberFloatArrAcceptDef(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDef", X)); 163 checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDef", X)); 164 checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDef", X)); 165 checkSingleMemberStringArrAcceptDef(UnitTest.class.getMethod("SingleMemberStringArrAcceptDef", X)); 166 checkSingleMemberClassArrAcceptDef(UnitTest.class.getMethod("SingleMemberClassArrAcceptDef", X)); 167 checkSingleMemberEnumArrAcceptDef(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDef", X)); 168 169 // *** TESTS ON ANNOTATED FIELDS *** 170 171 // MULTIMEMBER SCALAR TYPES ON FIELD 172 checkScalarTypes(UnitTest.class.getField("scalarTypesField")); 173 checkScalarTypesAcceptDefault(UnitTest.class.getField("scalarTypesAcceptDefaultField")); 174 checkScalarTypesOverrideDefault(UnitTest.class.getField("scalarTypesOverrideDefaultField")); 175 176 // MULTIMEMBER ARRAY TYPES ON FIELD 177 checkArrayTypes0(UnitTest.class.getField("emptyArrayTypesField")); 178 checkArrayTypes1(UnitTest.class.getField("singleElementArrayTypesField")); 179 checkArrayTypes2(UnitTest.class.getField("twoElementArrayTypesField")); 180 checkArrayTypesAcceptDefault(UnitTest.class.getField("arrayTypesAcceptDefaultField")); 181 checkArrayTypesOverrideDefault(UnitTest.class.getField("arrayTypesOverrideDefaultField")); 182 183 // MARKER TYPE ON FIELD 184 checkMarker(UnitTest.class.getField("markerField")); 185 186 // SINGLE-MEMBER SCALAR TYPES ON FIELD 187 checkSingleMemberByte(UnitTest.class.getField("SingleMemberByteField")); 188 checkSingleMemberShort(UnitTest.class.getField("SingleMemberShortField")); 189 checkSingleMemberInt(UnitTest.class.getField("SingleMemberIntField")); 190 checkSingleMemberLong(UnitTest.class.getField("SingleMemberLongField")); 191 checkSingleMemberChar(UnitTest.class.getField("SingleMemberCharField")); 192 checkSingleMemberFloat(UnitTest.class.getField("SingleMemberFloatField")); 193 checkSingleMemberDouble(UnitTest.class.getField("SingleMemberDoubleField")); 194 checkSingleMemberBoolean(UnitTest.class.getField("SingleMemberBooleanField")); 195 checkSingleMemberString(UnitTest.class.getField("SingleMemberStringField")); 196 checkSingleMemberClass(UnitTest.class.getField("SingleMemberClassField")); 197 checkSingleMemberEnum(UnitTest.class.getField("SingleMemberEnumField")); 198 199 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON FIELD 200 checkSingleMemberByteOvrdDef(UnitTest.class.getField("SingleMemberByteOvrdDefField")); 201 checkSingleMemberShortOvrdDef(UnitTest.class.getField("SingleMemberShortOvrdDefField")); 202 checkSingleMemberIntOvrdDef(UnitTest.class.getField("SingleMemberIntOvrdDefField")); 203 checkSingleMemberLongOvrdDef(UnitTest.class.getField("SingleMemberLongOvrdDefField")); 204 checkSingleMemberCharOvrdDef(UnitTest.class.getField("SingleMemberCharOvrdDefField")); 205 checkSingleMemberFloatOvrdDef(UnitTest.class.getField("SingleMemberFloatOvrdDefField")); 206 checkSingleMemberDoubleOvrdDef(UnitTest.class.getField("SingleMemberDoubleOvrdDefField")); 207 checkSingleMemberBooleanOvrdDef(UnitTest.class.getField("SingleMemberBooleanOvrdDefField")); 208 checkSingleMemberStringOvrdDef(UnitTest.class.getField("SingleMemberStringOvrdDefField")); 209 checkSingleMemberClassOvrdDef(UnitTest.class.getField("SingleMemberClassOvrdDefField")); 210 checkSingleMemberEnumOvrdDef(UnitTest.class.getField("SingleMemberEnumOvrdDefField")); 211 212 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON FIELD 213 checkSingleMemberByteAcceptDef(UnitTest.class.getField("SingleMemberByteAcceptDefField")); 214 checkSingleMemberShortAcceptDef(UnitTest.class.getField("SingleMemberShortAcceptDefField")); 215 checkSingleMemberIntAcceptDef(UnitTest.class.getField("SingleMemberIntAcceptDefField")); 216 checkSingleMemberLongAcceptDef(UnitTest.class.getField("SingleMemberLongAcceptDefField")); 217 checkSingleMemberCharAcceptDef(UnitTest.class.getField("SingleMemberCharAcceptDefField")); 218 checkSingleMemberFloatAcceptDef(UnitTest.class.getField("SingleMemberFloatAcceptDefField")); 219 checkSingleMemberDoubleAcceptDef(UnitTest.class.getField("SingleMemberDoubleAcceptDefField")); 220 checkSingleMemberBooleanAcceptDef(UnitTest.class.getField("SingleMemberBooleanAcceptDefField")); 221 checkSingleMemberStringAcceptDef(UnitTest.class.getField("SingleMemberStringAcceptDefField")); 222 checkSingleMemberClassAcceptDef(UnitTest.class.getField("SingleMemberClassAcceptDefField")); 223 checkSingleMemberEnumAcceptDef(UnitTest.class.getField("SingleMemberEnumAcceptDefField")); 224 225 // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON FIELD 226 checkSingleMemberByteArrEmpty(UnitTest.class.getField("SingleMemberByteArrEmptyField")); 227 checkSingleMemberShortArrEmpty(UnitTest.class.getField("SingleMemberShortArrEmptyField")); 228 checkSingleMemberIntArrEmpty(UnitTest.class.getField("SingleMemberIntArrEmptyField")); 229 checkSingleMemberLongArrEmpty(UnitTest.class.getField("SingleMemberLongArrEmptyField")); 230 checkSingleMemberCharArrEmpty(UnitTest.class.getField("SingleMemberCharArrEmptyField")); 231 checkSingleMemberFloatArrEmpty(UnitTest.class.getField("SingleMemberFloatArrEmptyField")); 232 checkSingleMemberDoubleArrEmpty(UnitTest.class.getField("SingleMemberDoubleArrEmptyField")); 233 checkSingleMemberBooleanArrEmpty(UnitTest.class.getField("SingleMemberBooleanArrEmptyField")); 234 checkSingleMemberStringArrEmpty(UnitTest.class.getField("SingleMemberStringArrEmptyField")); 235 checkSingleMemberClassArrEmpty(UnitTest.class.getField("SingleMemberClassArrEmptyField")); 236 checkSingleMemberEnumArrEmpty(UnitTest.class.getField("SingleMemberEnumArrEmptyField")); 237 238 // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON FIELD 239 checkSingleMemberByteArrOne(UnitTest.class.getField("SingleMemberByteArrOneField")); 240 checkSingleMemberShortArrOne(UnitTest.class.getField("SingleMemberShortArrOneField")); 241 checkSingleMemberIntArrOne(UnitTest.class.getField("SingleMemberIntArrOneField")); 242 checkSingleMemberLongArrOne(UnitTest.class.getField("SingleMemberLongArrOneField")); 243 checkSingleMemberCharArrOne(UnitTest.class.getField("SingleMemberCharArrOneField")); 244 checkSingleMemberFloatArrOne(UnitTest.class.getField("SingleMemberFloatArrOneField")); 245 checkSingleMemberDoubleArrOne(UnitTest.class.getField("SingleMemberDoubleArrOneField")); 246 checkSingleMemberBooleanArrOne(UnitTest.class.getField("SingleMemberBooleanArrOneField")); 247 checkSingleMemberStringArrOne(UnitTest.class.getField("SingleMemberStringArrOneField")); 248 checkSingleMemberClassArrOne(UnitTest.class.getField("SingleMemberClassArrOneField")); 249 checkSingleMemberEnumArrOne(UnitTest.class.getField("SingleMemberEnumArrOneField")); 250 251 // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON FIELD 252 checkSingleMemberByteArrTwo(UnitTest.class.getField("SingleMemberByteArrTwoField")); 253 checkSingleMemberShortArrTwo(UnitTest.class.getField("SingleMemberShortArrTwoField")); 254 checkSingleMemberIntArrTwo(UnitTest.class.getField("SingleMemberIntArrTwoField")); 255 checkSingleMemberLongArrTwo(UnitTest.class.getField("SingleMemberLongArrTwoField")); 256 checkSingleMemberCharArrTwo(UnitTest.class.getField("SingleMemberCharArrTwoField")); 257 checkSingleMemberFloatArrTwo(UnitTest.class.getField("SingleMemberFloatArrTwoField")); 258 checkSingleMemberDoubleArrTwo(UnitTest.class.getField("SingleMemberDoubleArrTwoField")); 259 checkSingleMemberBooleanArrTwo(UnitTest.class.getField("SingleMemberBooleanArrTwoField")); 260 checkSingleMemberStringArrTwo(UnitTest.class.getField("SingleMemberStringArrTwoField")); 261 checkSingleMemberClassArrTwo(UnitTest.class.getField("SingleMemberClassArrTwoField")); 262 checkSingleMemberEnumArrTwo(UnitTest.class.getField("SingleMemberEnumArrTwoField")); 263 264 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON FIELD 265 checkSingleMemberByteArrOvrdDef(UnitTest.class.getField("SingleMemberByteArrOvrdDefField")); 266 checkSingleMemberShortArrOvrdDef(UnitTest.class.getField("SingleMemberShortArrOvrdDefField")); 267 checkSingleMemberIntArrOvrdDef(UnitTest.class.getField("SingleMemberIntArrOvrdDefField")); 268 checkSingleMemberLongArrOvrdDef(UnitTest.class.getField("SingleMemberLongArrOvrdDefField")); 269 checkSingleMemberCharArrOvrdDef(UnitTest.class.getField("SingleMemberCharArrOvrdDefField")); 270 checkSingleMemberFloatArrOvrdDef(UnitTest.class.getField("SingleMemberFloatArrOvrdDefField")); 271 checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField")); 272 checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField")); 273 checkSingleMemberStringArrOvrdDef(UnitTest.class.getField("SingleMemberStringArrOvrdDefField")); 274 checkSingleMemberClassArrOvrdDef(UnitTest.class.getField("SingleMemberClassArrOvrdDefField")); 275 checkSingleMemberEnumArrOvrdDef(UnitTest.class.getField("SingleMemberEnumArrOvrdDefField")); 276 277 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON FIELD 278 checkSingleMemberByteArrAcceptDef(UnitTest.class.getField("SingleMemberByteArrAcceptDefField")); 279 checkSingleMemberShortArrAcceptDef(UnitTest.class.getField("SingleMemberShortArrAcceptDefField")); 280 checkSingleMemberIntArrAcceptDef(UnitTest.class.getField("SingleMemberIntArrAcceptDefField")); 281 checkSingleMemberLongArrAcceptDef(UnitTest.class.getField("SingleMemberLongArrAcceptDefField")); 282 checkSingleMemberCharArrAcceptDef(UnitTest.class.getField("SingleMemberCharArrAcceptDefField")); 283 checkSingleMemberFloatArrAcceptDef(UnitTest.class.getField("SingleMemberFloatArrAcceptDefField")); 284 checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField")); 285 checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField")); 286 checkSingleMemberStringArrAcceptDef(UnitTest.class.getField("SingleMemberStringArrAcceptDefField")); 287 checkSingleMemberClassArrAcceptDef(UnitTest.class.getField("SingleMemberClassArrAcceptDefField")); 288 checkSingleMemberEnumArrAcceptDef(UnitTest.class.getField("SingleMemberEnumArrAcceptDefField")); 289 290 // *** TESTS ON ANNOTATED ENUM CONSTS *** 291 292 // MULTIMEMBER SCALAR TYPES ON ENUM CONST 293 checkScalarTypes(TestType.class.getField("scalarTypesField")); 294 checkScalarTypesAcceptDefault(TestType.class.getField("scalarTypesAcceptDefaultField")); 295 checkScalarTypesOverrideDefault(TestType.class.getField("scalarTypesOverrideDefaultField")); 296 297 // MULTIMEMBER ARRAY TYPES ON ENUM CONST 298 checkArrayTypes0(TestType.class.getField("emptyArrayTypesField")); 299 checkArrayTypes1(TestType.class.getField("singleElementArrayTypesField")); 300 checkArrayTypes2(TestType.class.getField("twoElementArrayTypesField")); 301 checkArrayTypesAcceptDefault(TestType.class.getField("arrayTypesAcceptDefaultField")); 302 checkArrayTypesOverrideDefault(TestType.class.getField("arrayTypesOverrideDefaultField")); 303 304 // MARKER TYPE ON CLASS 305 checkMarker(TestType.class.getField("marker")); 306 307 // SINGLE-MEMBER SCALAR TYPES ON CLASS 308 checkSingleMemberByte(TestType.class.getField("SingleMemberByte")); 309 checkSingleMemberShort(TestType.class.getField("SingleMemberShort")); 310 checkSingleMemberInt(TestType.class.getField("SingleMemberInt")); 311 checkSingleMemberLong(TestType.class.getField("SingleMemberLong")); 312 checkSingleMemberChar(TestType.class.getField("SingleMemberChar")); 313 checkSingleMemberFloat(TestType.class.getField("SingleMemberFloat")); 314 checkSingleMemberDouble(TestType.class.getField("SingleMemberDouble")); 315 checkSingleMemberBoolean(TestType.class.getField("SingleMemberBoolean")); 316 checkSingleMemberString(TestType.class.getField("SingleMemberString")); 317 checkSingleMemberClass(TestType.class.getField("SingleMemberClass")); 318 checkSingleMemberEnum(TestType.class.getField("SingleMemberEnum")); 319 320 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS 321 checkSingleMemberByteOvrdDef(TestType.class.getField("SingleMemberByteOvrdDef")); 322 checkSingleMemberShortOvrdDef(TestType.class.getField("SingleMemberShortOvrdDef")); 323 checkSingleMemberIntOvrdDef(TestType.class.getField("SingleMemberIntOvrdDef")); 324 checkSingleMemberLongOvrdDef(TestType.class.getField("SingleMemberLongOvrdDef")); 325 checkSingleMemberCharOvrdDef(TestType.class.getField("SingleMemberCharOvrdDef")); 326 checkSingleMemberFloatOvrdDef(TestType.class.getField("SingleMemberFloatOvrdDef")); 327 checkSingleMemberDoubleOvrdDef(TestType.class.getField("SingleMemberDoubleOvrdDef")); 328 checkSingleMemberBooleanOvrdDef(TestType.class.getField("SingleMemberBooleanOvrdDef")); 329 checkSingleMemberStringOvrdDef(TestType.class.getField("SingleMemberStringOvrdDef")); 330 checkSingleMemberClassOvrdDef(TestType.class.getField("SingleMemberClassOvrdDef")); 331 checkSingleMemberEnumOvrdDef(TestType.class.getField("SingleMemberEnumOvrdDef")); 332 333 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS 334 checkSingleMemberByteAcceptDef(TestType.class.getField("SingleMemberByteAcceptDef")); 335 checkSingleMemberShortAcceptDef(TestType.class.getField("SingleMemberShortAcceptDef")); 336 checkSingleMemberIntAcceptDef(TestType.class.getField("SingleMemberIntAcceptDef")); 337 checkSingleMemberLongAcceptDef(TestType.class.getField("SingleMemberLongAcceptDef")); 338 checkSingleMemberCharAcceptDef(TestType.class.getField("SingleMemberCharAcceptDef")); 339 checkSingleMemberFloatAcceptDef(TestType.class.getField("SingleMemberFloatAcceptDef")); 340 checkSingleMemberDoubleAcceptDef(TestType.class.getField("SingleMemberDoubleAcceptDef")); 341 checkSingleMemberBooleanAcceptDef(TestType.class.getField("SingleMemberBooleanAcceptDef")); 342 checkSingleMemberStringAcceptDef(TestType.class.getField("SingleMemberStringAcceptDef")); 343 checkSingleMemberClassAcceptDef(TestType.class.getField("SingleMemberClassAcceptDef")); 344 checkSingleMemberEnumAcceptDef(TestType.class.getField("SingleMemberEnumAcceptDef")); 345 346 // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("EMPTY ARRAY) ON CLASS 347 checkSingleMemberByteArrEmpty(TestType.class.getField("SingleMemberByteArrEmpty")); 348 checkSingleMemberShortArrEmpty(TestType.class.getField("SingleMemberShortArrEmpty")); 349 checkSingleMemberIntArrEmpty(TestType.class.getField("SingleMemberIntArrEmpty")); 350 checkSingleMemberLongArrEmpty(TestType.class.getField("SingleMemberLongArrEmpty")); 351 checkSingleMemberCharArrEmpty(TestType.class.getField("SingleMemberCharArrEmpty")); 352 checkSingleMemberFloatArrEmpty(TestType.class.getField("SingleMemberFloatArrEmpty")); 353 checkSingleMemberDoubleArrEmpty(TestType.class.getField("SingleMemberDoubleArrEmpty")); 354 checkSingleMemberBooleanArrEmpty(TestType.class.getField("SingleMemberBooleanArrEmpty")); 355 checkSingleMemberStringArrEmpty(TestType.class.getField("SingleMemberStringArrEmpty")); 356 checkSingleMemberClassArrEmpty(TestType.class.getField("SingleMemberClassArrEmpty")); 357 checkSingleMemberEnumArrEmpty(TestType.class.getField("SingleMemberEnumArrEmpty")); 358 359 // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("ONE-ELEMENT ARRAY) ON CLASS 360 checkSingleMemberByteArrOne(TestType.class.getField("SingleMemberByteArrOne")); 361 checkSingleMemberShortArrOne(TestType.class.getField("SingleMemberShortArrOne")); 362 checkSingleMemberIntArrOne(TestType.class.getField("SingleMemberIntArrOne")); 363 checkSingleMemberLongArrOne(TestType.class.getField("SingleMemberLongArrOne")); 364 checkSingleMemberCharArrOne(TestType.class.getField("SingleMemberCharArrOne")); 365 checkSingleMemberFloatArrOne(TestType.class.getField("SingleMemberFloatArrOne")); 366 checkSingleMemberDoubleArrOne(TestType.class.getField("SingleMemberDoubleArrOne")); 367 checkSingleMemberBooleanArrOne(TestType.class.getField("SingleMemberBooleanArrOne")); 368 checkSingleMemberStringArrOne(TestType.class.getField("SingleMemberStringArrOne")); 369 checkSingleMemberClassArrOne(TestType.class.getField("SingleMemberClassArrOne")); 370 checkSingleMemberEnumArrOne(TestType.class.getField("SingleMemberEnumArrOne")); 371 372 // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("TWO-ELEMENT ARRAY) ON CLASS 373 checkSingleMemberByteArrTwo(TestType.class.getField("SingleMemberByteArrTwo")); 374 checkSingleMemberShortArrTwo(TestType.class.getField("SingleMemberShortArrTwo")); 375 checkSingleMemberIntArrTwo(TestType.class.getField("SingleMemberIntArrTwo")); 376 checkSingleMemberLongArrTwo(TestType.class.getField("SingleMemberLongArrTwo")); 377 checkSingleMemberCharArrTwo(TestType.class.getField("SingleMemberCharArrTwo")); 378 checkSingleMemberFloatArrTwo(TestType.class.getField("SingleMemberFloatArrTwo")); 379 checkSingleMemberDoubleArrTwo(TestType.class.getField("SingleMemberDoubleArrTwo")); 380 checkSingleMemberBooleanArrTwo(TestType.class.getField("SingleMemberBooleanArrTwo")); 381 checkSingleMemberStringArrTwo(TestType.class.getField("SingleMemberStringArrTwo")); 382 checkSingleMemberClassArrTwo(TestType.class.getField("SingleMemberClassArrTwo")); 383 checkSingleMemberEnumArrTwo(TestType.class.getField("SingleMemberEnumArrTwo")); 384 385 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("OVERRIDE)ON CLASS 386 checkSingleMemberByteArrOvrdDef(TestType.class.getField("SingleMemberByteArrOvrdDef")); 387 checkSingleMemberShortArrOvrdDef(TestType.class.getField("SingleMemberShortArrOvrdDef")); 388 checkSingleMemberIntArrOvrdDef(TestType.class.getField("SingleMemberIntArrOvrdDef")); 389 checkSingleMemberLongArrOvrdDef(TestType.class.getField("SingleMemberLongArrOvrdDef")); 390 checkSingleMemberCharArrOvrdDef(TestType.class.getField("SingleMemberCharArrOvrdDef")); 391 checkSingleMemberFloatArrOvrdDef(TestType.class.getField("SingleMemberFloatArrOvrdDef")); 392 checkSingleMemberDoubleArrOvrdDef(TestType.class.getField("SingleMemberDoubleArrOvrdDef")); 393 checkSingleMemberBooleanArrOvrdDef(TestType.class.getField("SingleMemberBooleanArrOvrdDef")); 394 checkSingleMemberStringArrOvrdDef(TestType.class.getField("SingleMemberStringArrOvrdDef")); 395 checkSingleMemberClassArrOvrdDef(TestType.class.getField("SingleMemberClassArrOvrdDef")); 396 checkSingleMemberEnumArrOvrdDef(TestType.class.getField("SingleMemberEnumArrOvrdDef")); 397 398 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("ACCEPT)ON CLASS 399 checkSingleMemberByteArrAcceptDef(TestType.class.getField("SingleMemberByteArrAcceptDef")); 400 checkSingleMemberShortArrAcceptDef(TestType.class.getField("SingleMemberShortArrAcceptDef")); 401 checkSingleMemberIntArrAcceptDef(TestType.class.getField("SingleMemberIntArrAcceptDef")); 402 checkSingleMemberLongArrAcceptDef(TestType.class.getField("SingleMemberLongArrAcceptDef")); 403 checkSingleMemberCharArrAcceptDef(TestType.class.getField("SingleMemberCharArrAcceptDef")); 404 checkSingleMemberFloatArrAcceptDef(TestType.class.getField("SingleMemberFloatArrAcceptDef")); 405 checkSingleMemberDoubleArrAcceptDef(TestType.class.getField("SingleMemberDoubleArrAcceptDef")); 406 checkSingleMemberBooleanArrAcceptDef(TestType.class.getField("SingleMemberBooleanArrAcceptDef")); 407 checkSingleMemberStringArrAcceptDef(TestType.class.getField("SingleMemberStringArrAcceptDef")); 408 checkSingleMemberClassArrAcceptDef(TestType.class.getField("SingleMemberClassArrAcceptDef")); 409 checkSingleMemberEnumArrAcceptDef(TestType.class.getField("SingleMemberEnumArrAcceptDef")); 410 411 // *** TESTS ON ANNOTATED CONSTRUCTORS *** 412 413 // MULTIMEMBER SCALAR TYPES ON CONSTRUCTOR 414 checkScalarTypes(UnitTest.class.getConstructor(new Class[]{Iterator.class})); 415 checkScalarTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{Map.class})); 416 checkScalarTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{Set.class})); 417 418 // MULTIMEMBER ARRAY TYPES ON CONSTRUCTOR 419 checkArrayTypes0(UnitTest.class.getConstructor(new Class[]{List.class})); 420 checkArrayTypes1(UnitTest.class.getConstructor(new Class[]{Collection.class})); 421 checkArrayTypes2(UnitTest.class.getConstructor(new Class[]{SortedSet.class})); 422 checkArrayTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{SortedMap.class})); 423 checkArrayTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{RandomAccess.class})); 424 425 // MARKER TYPE ON CONSTRUCTOR 426 checkMarker(UnitTest.class.getConstructor(new Class[] { })); 427 428 // SINGLE-MEMBER SCALAR TYPES ON CONSTRUCTOR 429 checkSingleMemberByte(UnitTest.class.getConstructor(new Class[] { byte.class })); 430 checkSingleMemberShort(UnitTest.class.getConstructor(new Class[] { short.class })); 431 checkSingleMemberInt(UnitTest.class.getConstructor(new Class[] { int.class })); 432 checkSingleMemberLong(UnitTest.class.getConstructor(new Class[] { long.class })); 433 checkSingleMemberChar(UnitTest.class.getConstructor(new Class[] { char.class })); 434 checkSingleMemberFloat(UnitTest.class.getConstructor(new Class[] { float.class })); 435 checkSingleMemberDouble(UnitTest.class.getConstructor(new Class[] { double.class })); 436 checkSingleMemberBoolean(UnitTest.class.getConstructor(new Class[] { boolean.class })); 437 checkSingleMemberString(UnitTest.class.getConstructor(new Class[] { String.class })); 438 checkSingleMemberClass(UnitTest.class.getConstructor(new Class[] { Class.class })); 439 checkSingleMemberEnum(UnitTest.class.getConstructor(new Class[] { Enum.class })); 440 441 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CONSTRUCTOR 442 checkSingleMemberByteOvrdDef(UnitTest.class.getConstructor(new Class[] { byte.class, Set.class })); 443 checkSingleMemberShortOvrdDef(UnitTest.class.getConstructor(new Class[] { short.class, Set.class })); 444 checkSingleMemberIntOvrdDef(UnitTest.class.getConstructor(new Class[] { int.class, Set.class })); 445 checkSingleMemberLongOvrdDef(UnitTest.class.getConstructor(new Class[] { long.class, Set.class })); 446 checkSingleMemberCharOvrdDef(UnitTest.class.getConstructor(new Class[] { char.class, Set.class })); 447 checkSingleMemberFloatOvrdDef(UnitTest.class.getConstructor(new Class[] { float.class, Set.class })); 448 checkSingleMemberDoubleOvrdDef(UnitTest.class.getConstructor(new Class[] { double.class, Set.class })); 449 checkSingleMemberBooleanOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Set.class })); 450 checkSingleMemberStringOvrdDef(UnitTest.class.getConstructor(new Class[] { String.class, Set.class })); 451 checkSingleMemberClassOvrdDef(UnitTest.class.getConstructor(new Class[] { Class.class, Set.class })); 452 checkSingleMemberEnumOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Set.class })); 453 454 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CONSTRUCTOR 455 checkSingleMemberByteAcceptDef(UnitTest.class.getConstructor(new Class[] { byte.class, Map.class })); 456 checkSingleMemberShortAcceptDef(UnitTest.class.getConstructor(new Class[] { short.class, Map.class })); 457 checkSingleMemberIntAcceptDef(UnitTest.class.getConstructor(new Class[] { int.class, Map.class })); 458 checkSingleMemberLongAcceptDef(UnitTest.class.getConstructor(new Class[] { long.class, Map.class })); 459 checkSingleMemberCharAcceptDef(UnitTest.class.getConstructor(new Class[] { char.class, Map.class })); 460 checkSingleMemberFloatAcceptDef(UnitTest.class.getConstructor(new Class[] { float.class, Map.class })); 461 checkSingleMemberDoubleAcceptDef(UnitTest.class.getConstructor(new Class[] { double.class, Map.class })); 462 checkSingleMemberBooleanAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Map.class })); 463 checkSingleMemberStringAcceptDef(UnitTest.class.getConstructor(new Class[] { String.class, Map.class })); 464 checkSingleMemberClassAcceptDef(UnitTest.class.getConstructor(new Class[] { Class.class, Map.class })); 465 checkSingleMemberEnumAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Map.class })); 466 467 // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CONSTRUCTOR 468 checkSingleMemberByteArrEmpty(UnitTest.class.getConstructor(new Class[] { byte[].class })); 469 checkSingleMemberShortArrEmpty(UnitTest.class.getConstructor(new Class[] { short[].class })); 470 checkSingleMemberIntArrEmpty(UnitTest.class.getConstructor(new Class[] { int[].class })); 471 checkSingleMemberLongArrEmpty(UnitTest.class.getConstructor(new Class[] { long[].class })); 472 checkSingleMemberCharArrEmpty(UnitTest.class.getConstructor(new Class[] { char[].class })); 473 checkSingleMemberFloatArrEmpty(UnitTest.class.getConstructor(new Class[] { float[].class })); 474 checkSingleMemberDoubleArrEmpty(UnitTest.class.getConstructor(new Class[] { double[].class })); 475 checkSingleMemberBooleanArrEmpty(UnitTest.class.getConstructor(new Class[] { boolean[].class })); 476 checkSingleMemberStringArrEmpty(UnitTest.class.getConstructor(new Class[] { String[].class })); 477 checkSingleMemberClassArrEmpty(UnitTest.class.getConstructor(new Class[] { Class[].class })); 478 checkSingleMemberEnumArrEmpty(UnitTest.class.getConstructor(new Class[] { Enum[].class })); 479 480 // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CONSTRUCTOR 481 checkSingleMemberByteArrOne(UnitTest.class.getConstructor(new Class[] { byte[].class, Set.class })); 482 checkSingleMemberShortArrOne(UnitTest.class.getConstructor(new Class[] { short[].class, Set.class })); 483 checkSingleMemberIntArrOne(UnitTest.class.getConstructor(new Class[] { int[].class, Set.class })); 484 checkSingleMemberLongArrOne(UnitTest.class.getConstructor(new Class[] { long[].class, Set.class })); 485 checkSingleMemberCharArrOne(UnitTest.class.getConstructor(new Class[] { char[].class, Set.class })); 486 checkSingleMemberFloatArrOne(UnitTest.class.getConstructor(new Class[] { float[].class, Set.class })); 487 checkSingleMemberDoubleArrOne(UnitTest.class.getConstructor(new Class[] { double[].class, Set.class })); 488 checkSingleMemberBooleanArrOne(UnitTest.class.getConstructor(new Class[] { boolean[].class, Set.class })); 489 checkSingleMemberStringArrOne(UnitTest.class.getConstructor(new Class[] { String[].class, Set.class })); 490 checkSingleMemberClassArrOne(UnitTest.class.getConstructor(new Class[] { Class[].class, Set.class })); 491 checkSingleMemberEnumArrOne(UnitTest.class.getConstructor(new Class[] { Enum[].class, Set.class })); 492 493 // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CONSTRUCTOR 494 checkSingleMemberByteArrTwo(UnitTest.class.getConstructor(new Class[] { byte[].class, Map.class })); 495 checkSingleMemberShortArrTwo(UnitTest.class.getConstructor(new Class[] { short[].class, Map.class })); 496 checkSingleMemberIntArrTwo(UnitTest.class.getConstructor(new Class[] { int[].class, Map.class })); 497 checkSingleMemberLongArrTwo(UnitTest.class.getConstructor(new Class[] { long[].class, Map.class })); 498 checkSingleMemberCharArrTwo(UnitTest.class.getConstructor(new Class[] { char[].class, Map.class })); 499 checkSingleMemberFloatArrTwo(UnitTest.class.getConstructor(new Class[] { float[].class, Map.class })); 500 checkSingleMemberDoubleArrTwo(UnitTest.class.getConstructor(new Class[] { double[].class, Map.class })); 501 checkSingleMemberBooleanArrTwo(UnitTest.class.getConstructor(new Class[] { boolean[].class, Map.class })); 502 checkSingleMemberStringArrTwo(UnitTest.class.getConstructor(new Class[] { String[].class, Map.class })); 503 checkSingleMemberClassArrTwo(UnitTest.class.getConstructor(new Class[] { Class[].class, Map.class })); 504 checkSingleMemberEnumArrTwo(UnitTest.class.getConstructor(new Class[] { Enum[].class, Map.class })); 505 506 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CONSTRUCTOR 507 checkSingleMemberByteArrOvrdDef(UnitTest.class.getConstructor(new Class[] { byte[].class, List.class })); 508 checkSingleMemberShortArrOvrdDef(UnitTest.class.getConstructor(new Class[] { short[].class, List.class })); 509 checkSingleMemberIntArrOvrdDef(UnitTest.class.getConstructor(new Class[] { int[].class, List.class })); 510 checkSingleMemberLongArrOvrdDef(UnitTest.class.getConstructor(new Class[] { long[].class, List.class })); 511 checkSingleMemberCharArrOvrdDef(UnitTest.class.getConstructor(new Class[] { char[].class, List.class })); 512 checkSingleMemberFloatArrOvrdDef(UnitTest.class.getConstructor(new Class[] { float[].class, List.class })); 513 checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getConstructor(new Class[] { double[].class, List.class })); 514 checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, List.class })); 515 checkSingleMemberStringArrOvrdDef(UnitTest.class.getConstructor(new Class[] { String[].class, List.class })); 516 checkSingleMemberClassArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Class[].class, List.class })); 517 checkSingleMemberEnumArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, List.class })); 518 519 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CONSTRUCTOR 520 checkSingleMemberByteArrAcceptDef(UnitTest.class.getConstructor(new Class[] { byte[].class, Collection.class })); 521 checkSingleMemberShortArrAcceptDef(UnitTest.class.getConstructor(new Class[] { short[].class, Collection.class })); 522 checkSingleMemberIntArrAcceptDef(UnitTest.class.getConstructor(new Class[] { int[].class, Collection.class })); 523 checkSingleMemberLongArrAcceptDef(UnitTest.class.getConstructor(new Class[] { long[].class, Collection.class })); 524 checkSingleMemberCharArrAcceptDef(UnitTest.class.getConstructor(new Class[] { char[].class, Collection.class })); 525 checkSingleMemberFloatArrAcceptDef(UnitTest.class.getConstructor(new Class[] { float[].class, Collection.class })); 526 checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getConstructor(new Class[] { double[].class, Collection.class })); 527 checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, Collection.class })); 528 checkSingleMemberStringArrAcceptDef(UnitTest.class.getConstructor(new Class[] { String[].class, Collection.class })); 529 checkSingleMemberClassArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Class[].class, Collection.class })); 530 checkSingleMemberEnumArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, Collection.class })); 531 532 // *** TESTS ON ANNOTATED PARAMETERS *** 533 534 // MULTIMEMBER SCALAR TYPES ON PARAM 535 checkScalarTypesParam(UnitTest.class.getMethod("scalarTypesParam", Y)); 536 checkScalarTypesOverrideDefaultParam(UnitTest.class.getMethod("scalarTypesOverrideDefaultParam", Y)); 537 checkScalarTypesAcceptDefaultParam(UnitTest.class.getMethod("scalarTypesAcceptDefaultParam", Y)); 538 539 // MULTIMEMBER ARRAY TYPES ON PARAM 540 checkArrayTypes0Param(UnitTest.class.getMethod("emptyArrayTypesParam", Y)); 541 checkArrayTypes1Param(UnitTest.class.getMethod("singleElementArrayTypesParam", Y)); 542 checkArrayTypes2Param(UnitTest.class.getMethod("twoElementArrayTypesParam", Y)); 543 checkArrayTypesAcceptDefaultParam(UnitTest.class.getMethod("arrayTypesAcceptDefaultParam", Y)); 544 checkArrayTypesOverrideDefaultParam(UnitTest.class.getMethod("arrayTypesOverrideDefaultParam", Y)); 545 546 // MARKER TYPE ON PARAMETER 547 checkMarkerParam(UnitTest.class.getMethod("markerParam", Y)); 548 549 // SINGLE-MEMBER SCALAR TYPES ON PARAMETER 550 checkSingleMemberByteParam(UnitTest.class.getMethod("SingleMemberByteParam", Y)); 551 checkSingleMemberShortParam(UnitTest.class.getMethod("SingleMemberShortParam", Y)); 552 checkSingleMemberIntParam(UnitTest.class.getMethod("SingleMemberIntParam", Y)); 553 checkSingleMemberLongParam(UnitTest.class.getMethod("SingleMemberLongParam", Y)); 554 checkSingleMemberCharParam(UnitTest.class.getMethod("SingleMemberCharParam", Y)); 555 checkSingleMemberFloatParam(UnitTest.class.getMethod("SingleMemberFloatParam", Y)); 556 checkSingleMemberDoubleParam(UnitTest.class.getMethod("SingleMemberDoubleParam", Y)); 557 checkSingleMemberBooleanParam(UnitTest.class.getMethod("SingleMemberBooleanParam", Y)); 558 checkSingleMemberStringParam(UnitTest.class.getMethod("SingleMemberStringParam", Y)); 559 checkSingleMemberClassParam(UnitTest.class.getMethod("SingleMemberClassParam", Y)); 560 checkSingleMemberEnumParam(UnitTest.class.getMethod("SingleMemberEnumParam", Y)); 561 562 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON PARAMETER 563 checkSingleMemberByteOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteOvrdDefParam", Y)); 564 checkSingleMemberShortOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortOvrdDefParam", Y)); 565 checkSingleMemberIntOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntOvrdDefParam", Y)); 566 checkSingleMemberLongOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongOvrdDefParam", Y)); 567 checkSingleMemberCharOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharOvrdDefParam", Y)); 568 checkSingleMemberFloatOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatOvrdDefParam", Y)); 569 checkSingleMemberDoubleOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleOvrdDefParam", Y)); 570 checkSingleMemberBooleanOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanOvrdDefParam", Y)); 571 checkSingleMemberStringOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringOvrdDefParam", Y)); 572 checkSingleMemberClassOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassOvrdDefParam", Y)); 573 checkSingleMemberEnumOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumOvrdDefParam", Y)); 574 575 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON PARAMETER 576 checkSingleMemberByteAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteAcceptDefParam", Y)); 577 checkSingleMemberShortAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortAcceptDefParam", Y)); 578 checkSingleMemberIntAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntAcceptDefParam", Y)); 579 checkSingleMemberLongAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongAcceptDefParam", Y)); 580 checkSingleMemberCharAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharAcceptDefParam", Y)); 581 checkSingleMemberFloatAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatAcceptDefParam", Y)); 582 checkSingleMemberDoubleAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleAcceptDefParam", Y)); 583 checkSingleMemberBooleanAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanAcceptDefParam", Y)); 584 checkSingleMemberStringAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringAcceptDefParam", Y)); 585 checkSingleMemberClassAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassAcceptDefParam", Y)); 586 checkSingleMemberEnumAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumAcceptDefParam", Y)); 587 588 // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("EMPTY ARRAY) ON PARAMETER 589 checkSingleMemberByteArrEmptyParam(UnitTest.class.getMethod("SingleMemberByteArrEmptyParam", Y)); 590 checkSingleMemberShortArrEmptyParam(UnitTest.class.getMethod("SingleMemberShortArrEmptyParam", Y)); 591 checkSingleMemberIntArrEmptyParam(UnitTest.class.getMethod("SingleMemberIntArrEmptyParam", Y)); 592 checkSingleMemberLongArrEmptyParam(UnitTest.class.getMethod("SingleMemberLongArrEmptyParam", Y)); 593 checkSingleMemberCharArrEmptyParam(UnitTest.class.getMethod("SingleMemberCharArrEmptyParam", Y)); 594 checkSingleMemberFloatArrEmptyParam(UnitTest.class.getMethod("SingleMemberFloatArrEmptyParam", Y)); 595 checkSingleMemberDoubleArrEmptyParam(UnitTest.class.getMethod("SingleMemberDoubleArrEmptyParam", Y)); 596 checkSingleMemberBooleanArrEmptyParam(UnitTest.class.getMethod("SingleMemberBooleanArrEmptyParam", Y)); 597 checkSingleMemberStringArrEmptyParam(UnitTest.class.getMethod("SingleMemberStringArrEmptyParam", Y)); 598 checkSingleMemberClassArrEmptyParam(UnitTest.class.getMethod("SingleMemberClassArrEmptyParam", Y)); 599 checkSingleMemberEnumArrEmptyParam(UnitTest.class.getMethod("SingleMemberEnumArrEmptyParam", Y)); 600 601 // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("ONE-ELEMENT ARRAY) ON PARAMETER 602 checkSingleMemberByteArrOneParam(UnitTest.class.getMethod("SingleMemberByteArrOneParam", Y)); 603 checkSingleMemberShortArrOneParam(UnitTest.class.getMethod("SingleMemberShortArrOneParam", Y)); 604 checkSingleMemberIntArrOneParam(UnitTest.class.getMethod("SingleMemberIntArrOneParam", Y)); 605 checkSingleMemberLongArrOneParam(UnitTest.class.getMethod("SingleMemberLongArrOneParam", Y)); 606 checkSingleMemberCharArrOneParam(UnitTest.class.getMethod("SingleMemberCharArrOneParam", Y)); 607 checkSingleMemberFloatArrOneParam(UnitTest.class.getMethod("SingleMemberFloatArrOneParam", Y)); 608 checkSingleMemberDoubleArrOneParam(UnitTest.class.getMethod("SingleMemberDoubleArrOneParam", Y)); 609 checkSingleMemberBooleanArrOneParam(UnitTest.class.getMethod("SingleMemberBooleanArrOneParam", Y)); 610 checkSingleMemberStringArrOneParam(UnitTest.class.getMethod("SingleMemberStringArrOneParam", Y)); 611 checkSingleMemberClassArrOneParam(UnitTest.class.getMethod("SingleMemberClassArrOneParam", Y)); 612 checkSingleMemberEnumArrOneParam(UnitTest.class.getMethod("SingleMemberEnumArrOneParam", Y)); 613 614 // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("TWO-ELEMENT ARRAY) ON PARAMETER 615 checkSingleMemberByteArrTwoParam(UnitTest.class.getMethod("SingleMemberByteArrTwoParam", Y)); 616 checkSingleMemberShortArrTwoParam(UnitTest.class.getMethod("SingleMemberShortArrTwoParam", Y)); 617 checkSingleMemberIntArrTwoParam(UnitTest.class.getMethod("SingleMemberIntArrTwoParam", Y)); 618 checkSingleMemberLongArrTwoParam(UnitTest.class.getMethod("SingleMemberLongArrTwoParam", Y)); 619 checkSingleMemberCharArrTwoParam(UnitTest.class.getMethod("SingleMemberCharArrTwoParam", Y)); 620 checkSingleMemberFloatArrTwoParam(UnitTest.class.getMethod("SingleMemberFloatArrTwoParam", Y)); 621 checkSingleMemberDoubleArrTwoParam(UnitTest.class.getMethod("SingleMemberDoubleArrTwoParam", Y)); 622 checkSingleMemberBooleanArrTwoParam(UnitTest.class.getMethod("SingleMemberBooleanArrTwoParam", Y)); 623 checkSingleMemberStringArrTwoParam(UnitTest.class.getMethod("SingleMemberStringArrTwoParam", Y)); 624 checkSingleMemberClassArrTwoParam(UnitTest.class.getMethod("SingleMemberClassArrTwoParam", Y)); 625 checkSingleMemberEnumArrTwoParam(UnitTest.class.getMethod("SingleMemberEnumArrTwoParam", Y)); 626 627 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("OVERRIDE)ON PARAMETER 628 checkSingleMemberByteArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteArrOvrdDefParam", Y)); 629 checkSingleMemberShortArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortArrOvrdDefParam", Y)); 630 checkSingleMemberIntArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntArrOvrdDefParam", Y)); 631 checkSingleMemberLongArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongArrOvrdDefParam", Y)); 632 checkSingleMemberCharArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharArrOvrdDefParam", Y)); 633 checkSingleMemberFloatArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDefParam", Y)); 634 checkSingleMemberDoubleArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDefParam", Y)); 635 checkSingleMemberBooleanArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDefParam", Y)); 636 checkSingleMemberStringArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringArrOvrdDefParam", Y)); 637 checkSingleMemberClassArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassArrOvrdDefParam", Y)); 638 checkSingleMemberEnumArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDefParam", Y)); 639 640 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("ACCEPT)ON PARAMETER 641 checkSingleMemberByteArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteArrAcceptDefParam", Y)); 642 checkSingleMemberShortArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortArrAcceptDefParam", Y)); 643 checkSingleMemberIntArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntArrAcceptDefParam", Y)); 644 checkSingleMemberLongArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongArrAcceptDefParam", Y)); 645 checkSingleMemberCharArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharArrAcceptDefParam", Y)); 646 checkSingleMemberFloatArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDefParam", Y)); 647 checkSingleMemberDoubleArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDefParam", Y)); 648 checkSingleMemberBooleanArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDefParam", Y)); 649 checkSingleMemberStringArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringArrAcceptDefParam", Y)); 650 checkSingleMemberClassArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassArrAcceptDefParam", Y)); 651 checkSingleMemberEnumArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDefParam", Y)); 652 653 // *** TESTS ON ANNOTATED CLASSES *** 654 655 // MULTIMEMBER SCALAR TYPES ON CLASS 656 checkScalarTypes(scalarTypesClass.class); 657 checkScalarTypesOverrideDefault(scalarTypesOverrideDefaultClass.class); 658 checkScalarTypesAcceptDefault(scalarTypesAcceptDefaultClass.class); 659 660 // MULTIMEMBER ARRAY TYPES ON CLASS 661 checkArrayTypes0(emptyArrayTypesClass.class); 662 checkArrayTypes1(singleElementArrayTypesClass.class); 663 checkArrayTypes2(twoElementArrayTypesClass.class); 664 checkArrayTypesOverrideDefault(arrayTypesOverrideDefaultClass.class); 665 checkArrayTypesAcceptDefault(arrayTypesAcceptDefaultClass.class); 666 667 // MARKER TYPE ON CLASS 668 checkMarker(markerClass.class); 669 670 // SINGLE-MEMBER SCALAR TYPES ON CLASS 671 checkSingleMemberByte(SingleMemberByteClass.class); 672 checkSingleMemberShort(SingleMemberShortClass.class); 673 checkSingleMemberInt(SingleMemberIntClass.class); 674 checkSingleMemberLong(SingleMemberLongClass.class); 675 checkSingleMemberChar(SingleMemberCharClass.class); 676 checkSingleMemberFloat(SingleMemberFloatClass.class); 677 checkSingleMemberDouble(SingleMemberDoubleClass.class); 678 checkSingleMemberBoolean(SingleMemberBooleanClass.class); 679 checkSingleMemberString(SingleMemberStringClass.class); 680 checkSingleMemberClass(SingleMemberClassClass.class); 681 checkSingleMemberEnum(SingleMemberEnumClass.class); 682 683 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS 684 checkSingleMemberByteOvrdDef(SingleMemberByteOvrdDefClass.class); 685 checkSingleMemberShortOvrdDef(SingleMemberShortOvrdDefClass.class); 686 checkSingleMemberIntOvrdDef(SingleMemberIntOvrdDefClass.class); 687 checkSingleMemberLongOvrdDef(SingleMemberLongOvrdDefClass.class); 688 checkSingleMemberCharOvrdDef(SingleMemberCharOvrdDefClass.class); 689 checkSingleMemberFloatOvrdDef(SingleMemberFloatOvrdDefClass.class); 690 checkSingleMemberDoubleOvrdDef(SingleMemberDoubleOvrdDefClass.class); 691 checkSingleMemberBooleanOvrdDef(SingleMemberBooleanOvrdDefClass.class); 692 checkSingleMemberStringOvrdDef(SingleMemberStringOvrdDefClass.class); 693 checkSingleMemberClassOvrdDef(SingleMemberClassOvrdDefClass.class); 694 checkSingleMemberEnumOvrdDef(SingleMemberEnumOvrdDefClass.class); 695 696 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS 697 checkSingleMemberByteAcceptDef(SingleMemberByteAcceptDefClass.class); 698 checkSingleMemberShortAcceptDef(SingleMemberShortAcceptDefClass.class); 699 checkSingleMemberIntAcceptDef(SingleMemberIntAcceptDefClass.class); 700 checkSingleMemberLongAcceptDef(SingleMemberLongAcceptDefClass.class); 701 checkSingleMemberCharAcceptDef(SingleMemberCharAcceptDefClass.class); 702 checkSingleMemberFloatAcceptDef(SingleMemberFloatAcceptDefClass.class); 703 checkSingleMemberDoubleAcceptDef(SingleMemberDoubleAcceptDefClass.class); 704 checkSingleMemberBooleanAcceptDef(SingleMemberBooleanAcceptDefClass.class); 705 checkSingleMemberStringAcceptDef(SingleMemberStringAcceptDefClass.class); 706 checkSingleMemberClassAcceptDef(SingleMemberClassAcceptDefClass.class); 707 checkSingleMemberEnumAcceptDef(SingleMemberEnumAcceptDefClass.class); 708 709 // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CLASS 710 checkSingleMemberByteArrEmpty(SingleMemberByteArrEmptyClass.class); 711 checkSingleMemberShortArrEmpty(SingleMemberShortArrEmptyClass.class); 712 checkSingleMemberIntArrEmpty(SingleMemberIntArrEmptyClass.class); 713 checkSingleMemberLongArrEmpty(SingleMemberLongArrEmptyClass.class); 714 checkSingleMemberCharArrEmpty(SingleMemberCharArrEmptyClass.class); 715 checkSingleMemberFloatArrEmpty(SingleMemberFloatArrEmptyClass.class); 716 checkSingleMemberDoubleArrEmpty(SingleMemberDoubleArrEmptyClass.class); 717 checkSingleMemberBooleanArrEmpty(SingleMemberBooleanArrEmptyClass.class); 718 checkSingleMemberStringArrEmpty(SingleMemberStringArrEmptyClass.class); 719 checkSingleMemberClassArrEmpty(SingleMemberClassArrEmptyClass.class); 720 checkSingleMemberEnumArrEmpty(SingleMemberEnumArrEmptyClass.class); 721 722 // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CLASS 723 checkSingleMemberByteArrOne(SingleMemberByteArrOneClass.class); 724 checkSingleMemberShortArrOne(SingleMemberShortArrOneClass.class); 725 checkSingleMemberIntArrOne(SingleMemberIntArrOneClass.class); 726 checkSingleMemberLongArrOne(SingleMemberLongArrOneClass.class); 727 checkSingleMemberCharArrOne(SingleMemberCharArrOneClass.class); 728 checkSingleMemberFloatArrOne(SingleMemberFloatArrOneClass.class); 729 checkSingleMemberDoubleArrOne(SingleMemberDoubleArrOneClass.class); 730 checkSingleMemberBooleanArrOne(SingleMemberBooleanArrOneClass.class); 731 checkSingleMemberStringArrOne(SingleMemberStringArrOneClass.class); 732 checkSingleMemberClassArrOne(SingleMemberClassArrOneClass.class); 733 checkSingleMemberEnumArrOne(SingleMemberEnumArrOneClass.class); 734 735 // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CLASS 736 checkSingleMemberByteArrTwo(SingleMemberByteArrTwoClass.class); 737 checkSingleMemberShortArrTwo(SingleMemberShortArrTwoClass.class); 738 checkSingleMemberIntArrTwo(SingleMemberIntArrTwoClass.class); 739 checkSingleMemberLongArrTwo(SingleMemberLongArrTwoClass.class); 740 checkSingleMemberCharArrTwo(SingleMemberCharArrTwoClass.class); 741 checkSingleMemberFloatArrTwo(SingleMemberFloatArrTwoClass.class); 742 checkSingleMemberDoubleArrTwo(SingleMemberDoubleArrTwoClass.class); 743 checkSingleMemberBooleanArrTwo(SingleMemberBooleanArrTwoClass.class); 744 checkSingleMemberStringArrTwo(SingleMemberStringArrTwoClass.class); 745 checkSingleMemberClassArrTwo(SingleMemberClassArrTwoClass.class); 746 checkSingleMemberEnumArrTwo(SingleMemberEnumArrTwoClass.class); 747 748 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CLASS 749 checkSingleMemberByteArrOvrdDef(SingleMemberByteArrOvrdDefClass.class); 750 checkSingleMemberShortArrOvrdDef(SingleMemberShortArrOvrdDefClass.class); 751 checkSingleMemberIntArrOvrdDef(SingleMemberIntArrOvrdDefClass.class); 752 checkSingleMemberLongArrOvrdDef(SingleMemberLongArrOvrdDefClass.class); 753 checkSingleMemberCharArrOvrdDef(SingleMemberCharArrOvrdDefClass.class); 754 checkSingleMemberFloatArrOvrdDef(SingleMemberFloatArrOvrdDefClass.class); 755 checkSingleMemberDoubleArrOvrdDef(SingleMemberDoubleArrOvrdDefClass.class); 756 checkSingleMemberBooleanArrOvrdDef(SingleMemberBooleanArrOvrdDefClass.class); 757 checkSingleMemberStringArrOvrdDef(SingleMemberStringArrOvrdDefClass.class); 758 checkSingleMemberClassArrOvrdDef(SingleMemberClassArrOvrdDefClass.class); 759 checkSingleMemberEnumArrOvrdDef(SingleMemberEnumArrOvrdDefClass.class); 760 761 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CLASS 762 checkSingleMemberByteArrAcceptDef(SingleMemberByteArrAcceptDefClass.class); 763 checkSingleMemberShortArrAcceptDef(SingleMemberShortArrAcceptDefClass.class); 764 checkSingleMemberIntArrAcceptDef(SingleMemberIntArrAcceptDefClass.class); 765 checkSingleMemberLongArrAcceptDef(SingleMemberLongArrAcceptDefClass.class); 766 checkSingleMemberCharArrAcceptDef(SingleMemberCharArrAcceptDefClass.class); 767 checkSingleMemberFloatArrAcceptDef(SingleMemberFloatArrAcceptDefClass.class); 768 checkSingleMemberDoubleArrAcceptDef(SingleMemberDoubleArrAcceptDefClass.class); 769 checkSingleMemberBooleanArrAcceptDef(SingleMemberBooleanArrAcceptDefClass.class); 770 checkSingleMemberStringArrAcceptDef(SingleMemberStringArrAcceptDefClass.class); 771 checkSingleMemberClassArrAcceptDef(SingleMemberClassArrAcceptDefClass.class); 772 checkSingleMemberEnumArrAcceptDef(SingleMemberEnumArrAcceptDefClass.class); 773 774 // *** TESTS FOR EQUALS AND HASHCODE - POSITIVE 775 776 // MULTIMEMBER SCALAR TYPES 777 checkEquals(scalarTypesClass.class, UnitTest.class.getField("scalarTypesField"), 778 ScalarTypes.class); 779 checkEquals(scalarTypesOverrideDefaultClass.class, UnitTest.class.getField("scalarTypesOverrideDefaultField"), 780 ScalarTypesWithDefault.class); 781 checkEquals(scalarTypesAcceptDefaultClass.class, UnitTest.class.getField("scalarTypesAcceptDefaultField"), 782 ScalarTypesWithDefault.class); 783 784 // MULTIMEMBER ARRAY TYPES 785 checkEquals(emptyArrayTypesClass.class, UnitTest.class.getField("emptyArrayTypesField"), 786 ArrayTypes.class); 787 checkEquals(singleElementArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"), 788 ArrayTypes.class); 789 checkEquals(twoElementArrayTypesClass.class, UnitTest.class.getField("twoElementArrayTypesField"), 790 ArrayTypes.class); 791 checkEquals(arrayTypesOverrideDefaultClass.class, UnitTest.class.getField("arrayTypesOverrideDefaultField"), 792 ArrayTypesWithDefault.class); 793 checkEquals(arrayTypesAcceptDefaultClass.class, UnitTest.class.getField("arrayTypesAcceptDefaultField"), 794 ArrayTypesWithDefault.class); 795 796 // MARKER TYPE 797 checkEquals(markerClass.class, UnitTest.class.getField("markerField"), 798 Marker.class); 799 800 // SINGLE-MEMBER SCALAR TYPES 801 checkEquals(SingleMemberByteClass.class, UnitTest.class.getField("SingleMemberByteField"), 802 SingleMemberByte.class); 803 checkEquals(SingleMemberShortClass.class, UnitTest.class.getField("SingleMemberShortField"), 804 SingleMemberShort.class); 805 checkEquals(SingleMemberIntClass.class, UnitTest.class.getField("SingleMemberIntField"), 806 SingleMemberInt.class); 807 checkEquals(SingleMemberLongClass.class, UnitTest.class.getField("SingleMemberLongField"), 808 SingleMemberLong.class); 809 checkEquals(SingleMemberCharClass.class, UnitTest.class.getField("SingleMemberCharField"), 810 SingleMemberChar.class); 811 checkEquals(SingleMemberFloatClass.class, UnitTest.class.getField("SingleMemberFloatField"), 812 SingleMemberFloat.class); 813 checkEquals(SingleMemberDoubleClass.class, UnitTest.class.getField("SingleMemberDoubleField"), 814 SingleMemberDouble.class); 815 checkEquals(SingleMemberBooleanClass.class, UnitTest.class.getField("SingleMemberBooleanField"), 816 SingleMemberBoolean.class); 817 checkEquals(SingleMemberStringClass.class, UnitTest.class.getField("SingleMemberStringField"), 818 SingleMemberString.class); 819 checkEquals(SingleMemberClassClass.class, UnitTest.class.getField("SingleMemberClassField"), 820 SingleMemberClass.class); 821 checkEquals(SingleMemberEnumClass.class, UnitTest.class.getField("SingleMemberEnumField"), 822 SingleMemberEnum.class); 823 824 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE 825 checkEquals(SingleMemberByteOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteOvrdDefField"), 826 SingleMemberByteWithDef.class); 827 checkEquals(SingleMemberShortOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortOvrdDefField"), 828 SingleMemberShortWithDef.class); 829 checkEquals(SingleMemberIntOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntOvrdDefField"), 830 SingleMemberIntWithDef.class); 831 checkEquals(SingleMemberLongOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongOvrdDefField"), 832 SingleMemberLongWithDef.class); 833 checkEquals(SingleMemberCharOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharOvrdDefField"), 834 SingleMemberCharWithDef.class); 835 checkEquals(SingleMemberFloatOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatOvrdDefField"), 836 SingleMemberFloatWithDef.class); 837 checkEquals(SingleMemberDoubleOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleOvrdDefField"), 838 SingleMemberDoubleWithDef.class); 839 checkEquals(SingleMemberBooleanOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanOvrdDefField"), 840 SingleMemberBooleanWithDef.class); 841 checkEquals(SingleMemberStringOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringOvrdDefField"), 842 SingleMemberStringWithDef.class); 843 checkEquals(SingleMemberClassOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassOvrdDefField"), 844 SingleMemberClassWithDef.class); 845 checkEquals(SingleMemberEnumOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumOvrdDefField"), 846 SingleMemberEnumWithDef.class); 847 848 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT 849 checkEquals(SingleMemberByteAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteAcceptDefField"), 850 SingleMemberByteWithDef.class); 851 checkEquals(SingleMemberShortAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortAcceptDefField"), 852 SingleMemberShortWithDef.class); 853 checkEquals(SingleMemberIntAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntAcceptDefField"), 854 SingleMemberIntWithDef.class); 855 checkEquals(SingleMemberLongAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongAcceptDefField"), 856 SingleMemberLongWithDef.class); 857 checkEquals(SingleMemberCharAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharAcceptDefField"), 858 SingleMemberCharWithDef.class); 859 checkEquals(SingleMemberFloatAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatAcceptDefField"), 860 SingleMemberFloatWithDef.class); 861 checkEquals(SingleMemberDoubleAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleAcceptDefField"), 862 SingleMemberDoubleWithDef.class); 863 checkEquals(SingleMemberBooleanAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanAcceptDefField"), 864 SingleMemberBooleanWithDef.class); 865 checkEquals(SingleMemberStringAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringAcceptDefField"), 866 SingleMemberStringWithDef.class); 867 checkEquals(SingleMemberClassAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassAcceptDefField"), 868 SingleMemberClassWithDef.class); 869 checkEquals(SingleMemberEnumAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumAcceptDefField"), 870 SingleMemberEnumWithDef.class); 871 872 // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) 873 checkEquals(SingleMemberByteArrEmptyClass.class, UnitTest.class.getField("SingleMemberByteArrEmptyField"), 874 SingleMemberByteArray.class); 875 checkEquals(SingleMemberShortArrEmptyClass.class, UnitTest.class.getField("SingleMemberShortArrEmptyField"), 876 SingleMemberShortArray.class); 877 checkEquals(SingleMemberIntArrEmptyClass.class, UnitTest.class.getField("SingleMemberIntArrEmptyField"), 878 SingleMemberIntArray.class); 879 checkEquals(SingleMemberLongArrEmptyClass.class, UnitTest.class.getField("SingleMemberLongArrEmptyField"), 880 SingleMemberLongArray.class); 881 checkEquals(SingleMemberCharArrEmptyClass.class, UnitTest.class.getField("SingleMemberCharArrEmptyField"), 882 SingleMemberCharArray.class); 883 checkEquals(SingleMemberFloatArrEmptyClass.class, UnitTest.class.getField("SingleMemberFloatArrEmptyField"), 884 SingleMemberFloatArray.class); 885 checkEquals(SingleMemberDoubleArrEmptyClass.class, UnitTest.class.getField("SingleMemberDoubleArrEmptyField"), 886 SingleMemberDoubleArray.class); 887 checkEquals(SingleMemberBooleanArrEmptyClass.class, UnitTest.class.getField("SingleMemberBooleanArrEmptyField"), 888 SingleMemberBooleanArray.class); 889 checkEquals(SingleMemberStringArrEmptyClass.class, UnitTest.class.getField("SingleMemberStringArrEmptyField"), 890 SingleMemberStringArray.class); 891 checkEquals(SingleMemberClassArrEmptyClass.class, UnitTest.class.getField("SingleMemberClassArrEmptyField"), 892 SingleMemberClassArray.class); 893 checkEquals(SingleMemberEnumArrEmptyClass.class, UnitTest.class.getField("SingleMemberEnumArrEmptyField"), 894 SingleMemberEnumArray.class); 895 896 // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) 897 checkEquals(SingleMemberByteArrOneClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"), 898 SingleMemberByteArray.class); 899 checkEquals(SingleMemberShortArrOneClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"), 900 SingleMemberShortArray.class); 901 checkEquals(SingleMemberIntArrOneClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"), 902 SingleMemberIntArray.class); 903 checkEquals(SingleMemberLongArrOneClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"), 904 SingleMemberLongArray.class); 905 checkEquals(SingleMemberCharArrOneClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"), 906 SingleMemberCharArray.class); 907 checkEquals(SingleMemberFloatArrOneClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"), 908 SingleMemberFloatArray.class); 909 checkEquals(SingleMemberDoubleArrOneClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"), 910 SingleMemberDoubleArray.class); 911 checkEquals(SingleMemberBooleanArrOneClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"), 912 SingleMemberBooleanArray.class); 913 checkEquals(SingleMemberStringArrOneClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"), 914 SingleMemberStringArray.class); 915 checkEquals(SingleMemberClassArrOneClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"), 916 SingleMemberClassArray.class); 917 checkEquals(SingleMemberEnumArrOneClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"), 918 SingleMemberEnumArray.class); 919 920 // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) 921 checkEquals(SingleMemberByteArrTwoClass.class, UnitTest.class.getField("SingleMemberByteArrTwoField"), 922 SingleMemberByteArray.class); 923 checkEquals(SingleMemberShortArrTwoClass.class, UnitTest.class.getField("SingleMemberShortArrTwoField"), 924 SingleMemberShortArray.class); 925 checkEquals(SingleMemberIntArrTwoClass.class, UnitTest.class.getField("SingleMemberIntArrTwoField"), 926 SingleMemberIntArray.class); 927 checkEquals(SingleMemberLongArrTwoClass.class, UnitTest.class.getField("SingleMemberLongArrTwoField"), 928 SingleMemberLongArray.class); 929 checkEquals(SingleMemberCharArrTwoClass.class, UnitTest.class.getField("SingleMemberCharArrTwoField"), 930 SingleMemberCharArray.class); 931 checkEquals(SingleMemberFloatArrTwoClass.class, UnitTest.class.getField("SingleMemberFloatArrTwoField"), 932 SingleMemberFloatArray.class); 933 checkEquals(SingleMemberDoubleArrTwoClass.class, UnitTest.class.getField("SingleMemberDoubleArrTwoField"), 934 SingleMemberDoubleArray.class); 935 checkEquals(SingleMemberBooleanArrTwoClass.class, UnitTest.class.getField("SingleMemberBooleanArrTwoField"), 936 SingleMemberBooleanArray.class); 937 checkEquals(SingleMemberStringArrTwoClass.class, UnitTest.class.getField("SingleMemberStringArrTwoField"), 938 SingleMemberStringArray.class); 939 checkEquals(SingleMemberClassArrTwoClass.class, UnitTest.class.getField("SingleMemberClassArrTwoField"), 940 SingleMemberClassArray.class); 941 checkEquals(SingleMemberEnumArrTwoClass.class, UnitTest.class.getField("SingleMemberEnumArrTwoField"), 942 SingleMemberEnumArray.class); 943 944 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE) 945 checkEquals(SingleMemberByteArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteArrOvrdDefField"), 946 SingleMemberByteArrayDef.class); 947 checkEquals(SingleMemberShortArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortArrOvrdDefField"), 948 SingleMemberShortArrayDef.class); 949 checkEquals(SingleMemberIntArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntArrOvrdDefField"), 950 SingleMemberIntArrayDef.class); 951 checkEquals(SingleMemberLongArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongArrOvrdDefField"), 952 SingleMemberLongArrayDef.class); 953 checkEquals(SingleMemberCharArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharArrOvrdDefField"), 954 SingleMemberCharArrayDef.class); 955 checkEquals(SingleMemberFloatArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"), 956 SingleMemberFloatArrayDef.class); 957 checkEquals(SingleMemberDoubleArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"), 958 SingleMemberDoubleArrayDef.class); 959 checkEquals(SingleMemberBooleanArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"), 960 SingleMemberBooleanArrayDef.class); 961 checkEquals(SingleMemberStringArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringArrOvrdDefField"), 962 SingleMemberStringArrayDef.class); 963 checkEquals(SingleMemberClassArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassArrOvrdDefField"), 964 SingleMemberClassArrayDef.class); 965 checkEquals(SingleMemberEnumArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"), 966 SingleMemberEnumArrayDef.class); 967 968 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT) 969 checkEquals(SingleMemberByteArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteArrAcceptDefField"), 970 SingleMemberByteArrayDef.class); 971 checkEquals(SingleMemberShortArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortArrAcceptDefField"), 972 SingleMemberShortArrayDef.class); 973 checkEquals(SingleMemberIntArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntArrAcceptDefField"), 974 SingleMemberIntArrayDef.class); 975 checkEquals(SingleMemberLongArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongArrAcceptDefField"), 976 SingleMemberLongArrayDef.class); 977 checkEquals(SingleMemberCharArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharArrAcceptDefField"), 978 SingleMemberCharArrayDef.class); 979 checkEquals(SingleMemberFloatArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"), 980 SingleMemberFloatArrayDef.class); 981 checkEquals(SingleMemberDoubleArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"), 982 SingleMemberDoubleArrayDef.class); 983 checkEquals(SingleMemberBooleanArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"), 984 SingleMemberBooleanArrayDef.class); 985 checkEquals(SingleMemberStringArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringArrAcceptDefField"), 986 SingleMemberStringArrayDef.class); 987 checkEquals(SingleMemberClassArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassArrAcceptDefField"), 988 SingleMemberClassArrayDef.class); 989 checkEquals(SingleMemberEnumArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"), 990 SingleMemberEnumArrayDef.class); 991 992 // *** TESTS FOR EQUALS AND HASHCODE - NEGATIVE 993 994 // MULTIMEMBER SCALAR TYPES 995 checkUnequals(scalarTypesOverrideDefaultClass.class, UnitTest.class.getField("scalarTypesAcceptDefaultField"), 996 ScalarTypesWithDefault.class); 997 checkUnequals(scalarTypesAcceptDefaultClass.class, UnitTest.class.getField("scalarTypesOverrideDefaultField"), 998 ScalarTypesWithDefault.class); 999 1000 // MULTIMEMBER ARRAY TYPES 1001 checkUnequals(emptyArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"), 1002 ArrayTypes.class); 1003 checkUnequals(singleElementArrayTypesClass.class, UnitTest.class.getField("twoElementArrayTypesField"), 1004 ArrayTypes.class); 1005 checkUnequals(twoElementArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"), 1006 ArrayTypes.class); 1007 checkUnequals(arrayTypesOverrideDefaultClass.class, UnitTest.class.getField("arrayTypesAcceptDefaultField"), 1008 ArrayTypesWithDefault.class); 1009 checkUnequals(arrayTypesAcceptDefaultClass.class, UnitTest.class.getField("arrayTypesOverrideDefaultField"), 1010 ArrayTypesWithDefault.class); 1011 1012 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE 1013 checkUnequals(SingleMemberByteOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteAcceptDefField"), 1014 SingleMemberByteWithDef.class); 1015 checkUnequals(SingleMemberShortOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortAcceptDefField"), 1016 SingleMemberShortWithDef.class); 1017 checkUnequals(SingleMemberIntOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntAcceptDefField"), 1018 SingleMemberIntWithDef.class); 1019 checkUnequals(SingleMemberLongOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongAcceptDefField"), 1020 SingleMemberLongWithDef.class); 1021 checkUnequals(SingleMemberCharOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharAcceptDefField"), 1022 SingleMemberCharWithDef.class); 1023 checkUnequals(SingleMemberFloatOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatAcceptDefField"), 1024 SingleMemberFloatWithDef.class); 1025 checkUnequals(SingleMemberDoubleOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleAcceptDefField"), 1026 SingleMemberDoubleWithDef.class); 1027 checkUnequals(SingleMemberBooleanOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanAcceptDefField"), 1028 SingleMemberBooleanWithDef.class); 1029 checkUnequals(SingleMemberStringOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringAcceptDefField"), 1030 SingleMemberStringWithDef.class); 1031 checkUnequals(SingleMemberClassOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassAcceptDefField"), 1032 SingleMemberClassWithDef.class); 1033 checkUnequals(SingleMemberEnumOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumAcceptDefField"), 1034 SingleMemberEnumWithDef.class); 1035 1036 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT 1037 checkUnequals(SingleMemberByteAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteOvrdDefField"), 1038 SingleMemberByteWithDef.class); 1039 checkUnequals(SingleMemberShortAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortOvrdDefField"), 1040 SingleMemberShortWithDef.class); 1041 checkUnequals(SingleMemberIntAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntOvrdDefField"), 1042 SingleMemberIntWithDef.class); 1043 checkUnequals(SingleMemberLongAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongOvrdDefField"), 1044 SingleMemberLongWithDef.class); 1045 checkUnequals(SingleMemberCharAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharOvrdDefField"), 1046 SingleMemberCharWithDef.class); 1047 checkUnequals(SingleMemberFloatAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatOvrdDefField"), 1048 SingleMemberFloatWithDef.class); 1049 checkUnequals(SingleMemberDoubleAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleOvrdDefField"), 1050 SingleMemberDoubleWithDef.class); 1051 checkUnequals(SingleMemberBooleanAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanOvrdDefField"), 1052 SingleMemberBooleanWithDef.class); 1053 checkUnequals(SingleMemberStringAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringOvrdDefField"), 1054 SingleMemberStringWithDef.class); 1055 checkUnequals(SingleMemberClassAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassOvrdDefField"), 1056 SingleMemberClassWithDef.class); 1057 checkUnequals(SingleMemberEnumAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumOvrdDefField"), 1058 SingleMemberEnumWithDef.class); 1059 1060 // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) 1061 checkUnequals(SingleMemberByteArrEmptyClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"), 1062 SingleMemberByteArray.class); 1063 checkUnequals(SingleMemberShortArrEmptyClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"), 1064 SingleMemberShortArray.class); 1065 checkUnequals(SingleMemberIntArrEmptyClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"), 1066 SingleMemberIntArray.class); 1067 checkUnequals(SingleMemberLongArrEmptyClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"), 1068 SingleMemberLongArray.class); 1069 checkUnequals(SingleMemberCharArrEmptyClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"), 1070 SingleMemberCharArray.class); 1071 checkUnequals(SingleMemberFloatArrEmptyClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"), 1072 SingleMemberFloatArray.class); 1073 checkUnequals(SingleMemberDoubleArrEmptyClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"), 1074 SingleMemberDoubleArray.class); 1075 checkUnequals(SingleMemberBooleanArrEmptyClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"), 1076 SingleMemberBooleanArray.class); 1077 checkUnequals(SingleMemberStringArrEmptyClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"), 1078 SingleMemberStringArray.class); 1079 checkUnequals(SingleMemberClassArrEmptyClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"), 1080 SingleMemberClassArray.class); 1081 checkUnequals(SingleMemberEnumArrEmptyClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"), 1082 SingleMemberEnumArray.class); 1083 1084 // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) 1085 checkUnequals(SingleMemberByteArrOneClass.class, UnitTest.class.getField("SingleMemberByteArrTwoField"), 1086 SingleMemberByteArray.class); 1087 checkUnequals(SingleMemberShortArrOneClass.class, UnitTest.class.getField("SingleMemberShortArrTwoField"), 1088 SingleMemberShortArray.class); 1089 checkUnequals(SingleMemberIntArrOneClass.class, UnitTest.class.getField("SingleMemberIntArrTwoField"), 1090 SingleMemberIntArray.class); 1091 checkUnequals(SingleMemberLongArrOneClass.class, UnitTest.class.getField("SingleMemberLongArrTwoField"), 1092 SingleMemberLongArray.class); 1093 checkUnequals(SingleMemberCharArrOneClass.class, UnitTest.class.getField("SingleMemberCharArrTwoField"), 1094 SingleMemberCharArray.class); 1095 checkUnequals(SingleMemberFloatArrOneClass.class, UnitTest.class.getField("SingleMemberFloatArrTwoField"), 1096 SingleMemberFloatArray.class); 1097 checkUnequals(SingleMemberDoubleArrOneClass.class, UnitTest.class.getField("SingleMemberDoubleArrTwoField"), 1098 SingleMemberDoubleArray.class); 1099 checkUnequals(SingleMemberBooleanArrOneClass.class, UnitTest.class.getField("SingleMemberBooleanArrTwoField"), 1100 SingleMemberBooleanArray.class); 1101 checkUnequals(SingleMemberStringArrOneClass.class, UnitTest.class.getField("SingleMemberStringArrTwoField"), 1102 SingleMemberStringArray.class); 1103 checkUnequals(SingleMemberClassArrOneClass.class, UnitTest.class.getField("SingleMemberClassArrTwoField"), 1104 SingleMemberClassArray.class); 1105 checkUnequals(SingleMemberEnumArrOneClass.class, UnitTest.class.getField("SingleMemberEnumArrTwoField"), 1106 SingleMemberEnumArray.class); 1107 1108 // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) 1109 checkUnequals(SingleMemberByteArrTwoClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"), 1110 SingleMemberByteArray.class); 1111 checkUnequals(SingleMemberShortArrTwoClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"), 1112 SingleMemberShortArray.class); 1113 checkUnequals(SingleMemberIntArrTwoClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"), 1114 SingleMemberIntArray.class); 1115 checkUnequals(SingleMemberLongArrTwoClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"), 1116 SingleMemberLongArray.class); 1117 checkUnequals(SingleMemberCharArrTwoClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"), 1118 SingleMemberCharArray.class); 1119 checkUnequals(SingleMemberFloatArrTwoClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"), 1120 SingleMemberFloatArray.class); 1121 checkUnequals(SingleMemberDoubleArrTwoClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"), 1122 SingleMemberDoubleArray.class); 1123 checkUnequals(SingleMemberBooleanArrTwoClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"), 1124 SingleMemberBooleanArray.class); 1125 checkUnequals(SingleMemberStringArrTwoClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"), 1126 SingleMemberStringArray.class); 1127 checkUnequals(SingleMemberClassArrTwoClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"), 1128 SingleMemberClassArray.class); 1129 checkUnequals(SingleMemberEnumArrTwoClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"), 1130 SingleMemberEnumArray.class); 1131 1132 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE) 1133 checkUnequals(SingleMemberByteArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteArrAcceptDefField"), 1134 SingleMemberByteArrayDef.class); 1135 checkUnequals(SingleMemberShortArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortArrAcceptDefField"), 1136 SingleMemberShortArrayDef.class); 1137 checkUnequals(SingleMemberIntArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntArrAcceptDefField"), 1138 SingleMemberIntArrayDef.class); 1139 checkUnequals(SingleMemberLongArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongArrAcceptDefField"), 1140 SingleMemberLongArrayDef.class); 1141 checkUnequals(SingleMemberCharArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharArrAcceptDefField"), 1142 SingleMemberCharArrayDef.class); 1143 checkUnequals(SingleMemberFloatArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"), 1144 SingleMemberFloatArrayDef.class); 1145 checkUnequals(SingleMemberDoubleArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"), 1146 SingleMemberDoubleArrayDef.class); 1147 checkUnequals(SingleMemberBooleanArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"), 1148 SingleMemberBooleanArrayDef.class); 1149 checkUnequals(SingleMemberStringArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringArrAcceptDefField"), 1150 SingleMemberStringArrayDef.class); 1151 checkUnequals(SingleMemberClassArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassArrAcceptDefField"), 1152 SingleMemberClassArrayDef.class); 1153 checkUnequals(SingleMemberEnumArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"), 1154 SingleMemberEnumArrayDef.class); 1155 1156 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT) 1157 checkUnequals(SingleMemberByteArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteArrOvrdDefField"), 1158 SingleMemberByteArrayDef.class); 1159 checkUnequals(SingleMemberShortArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortArrOvrdDefField"), 1160 SingleMemberShortArrayDef.class); 1161 checkUnequals(SingleMemberIntArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntArrOvrdDefField"), 1162 SingleMemberIntArrayDef.class); 1163 checkUnequals(SingleMemberLongArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongArrOvrdDefField"), 1164 SingleMemberLongArrayDef.class); 1165 checkUnequals(SingleMemberCharArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharArrOvrdDefField"), 1166 SingleMemberCharArrayDef.class); 1167 checkUnequals(SingleMemberFloatArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"), 1168 SingleMemberFloatArrayDef.class); 1169 checkUnequals(SingleMemberDoubleArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"), 1170 SingleMemberDoubleArrayDef.class); 1171 checkUnequals(SingleMemberBooleanArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"), 1172 SingleMemberBooleanArrayDef.class); 1173 checkUnequals(SingleMemberStringArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringArrOvrdDefField"), 1174 SingleMemberStringArrayDef.class); 1175 checkUnequals(SingleMemberClassArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassArrOvrdDefField"), 1176 SingleMemberClassArrayDef.class); 1177 checkUnequals(SingleMemberEnumArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"), 1178 SingleMemberEnumArrayDef.class); 1179 1180 // *** TESTS FOR SERIALIZATION AND DESERIALIZATION 1181 1182 // MULTIMEMBER SCALAR TYPES 1183 checkSerialization(scalarTypesClass.class, ScalarTypes.class); 1184 checkSerialization(scalarTypesOverrideDefaultClass.class, ScalarTypesWithDefault.class); 1185 checkSerialization(scalarTypesAcceptDefaultClass.class, ScalarTypesWithDefault.class); 1186 1187 // MULTIMEMBER ARRAY TYPES 1188 checkSerialization(emptyArrayTypesClass.class, ArrayTypes.class); 1189 checkSerialization(singleElementArrayTypesClass.class, ArrayTypes.class); 1190 checkSerialization(twoElementArrayTypesClass.class, ArrayTypes.class); 1191 checkSerialization(arrayTypesOverrideDefaultClass.class, ArrayTypesWithDefault.class); 1192 checkSerialization(arrayTypesAcceptDefaultClass.class, ArrayTypesWithDefault.class); 1193 1194 // MARKER TYPE 1195 checkSerialization(markerClass.class, Marker.class); 1196 1197 // SINGLE-MEMBER SCALAR TYPES 1198 checkSerialization(SingleMemberByteClass.class, SingleMemberByte.class); 1199 checkSerialization(SingleMemberShortClass.class, SingleMemberShort.class); 1200 checkSerialization(SingleMemberIntClass.class, SingleMemberInt.class); 1201 checkSerialization(SingleMemberLongClass.class, SingleMemberLong.class); 1202 checkSerialization(SingleMemberCharClass.class, SingleMemberChar.class); 1203 checkSerialization(SingleMemberFloatClass.class, SingleMemberFloat.class); 1204 checkSerialization(SingleMemberDoubleClass.class, SingleMemberDouble.class); 1205 checkSerialization(SingleMemberBooleanClass.class, SingleMemberBoolean.class); 1206 checkSerialization(SingleMemberStringClass.class, SingleMemberString.class); 1207 checkSerialization(SingleMemberClassClass.class, SingleMemberClass.class); 1208 checkSerialization(SingleMemberEnumClass.class, SingleMemberEnum.class); 1209 1210 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE 1211 checkSerialization(SingleMemberByteOvrdDefClass.class, SingleMemberByteWithDef.class); 1212 checkSerialization(SingleMemberShortOvrdDefClass.class, SingleMemberShortWithDef.class); 1213 checkSerialization(SingleMemberIntOvrdDefClass.class, SingleMemberIntWithDef.class); 1214 checkSerialization(SingleMemberLongOvrdDefClass.class, SingleMemberLongWithDef.class); 1215 checkSerialization(SingleMemberCharOvrdDefClass.class, SingleMemberCharWithDef.class); 1216 checkSerialization(SingleMemberFloatOvrdDefClass.class, SingleMemberFloatWithDef.class); 1217 checkSerialization(SingleMemberDoubleOvrdDefClass.class, SingleMemberDoubleWithDef.class); 1218 checkSerialization(SingleMemberBooleanOvrdDefClass.class, SingleMemberBooleanWithDef.class); 1219 checkSerialization(SingleMemberStringOvrdDefClass.class, SingleMemberStringWithDef.class); 1220 checkSerialization(SingleMemberClassOvrdDefClass.class, SingleMemberClassWithDef.class); 1221 checkSerialization(SingleMemberEnumOvrdDefClass.class, SingleMemberEnumWithDef.class); 1222 1223 // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT 1224 checkSerialization(SingleMemberByteAcceptDefClass.class, SingleMemberByteWithDef.class); 1225 checkSerialization(SingleMemberShortAcceptDefClass.class, SingleMemberShortWithDef.class); 1226 checkSerialization(SingleMemberIntAcceptDefClass.class, SingleMemberIntWithDef.class); 1227 checkSerialization(SingleMemberLongAcceptDefClass.class, SingleMemberLongWithDef.class); 1228 checkSerialization(SingleMemberCharAcceptDefClass.class, SingleMemberCharWithDef.class); 1229 checkSerialization(SingleMemberFloatAcceptDefClass.class, SingleMemberFloatWithDef.class); 1230 checkSerialization(SingleMemberDoubleAcceptDefClass.class, SingleMemberDoubleWithDef.class); 1231 checkSerialization(SingleMemberBooleanAcceptDefClass.class, SingleMemberBooleanWithDef.class); 1232 checkSerialization(SingleMemberStringAcceptDefClass.class, SingleMemberStringWithDef.class); 1233 checkSerialization(SingleMemberClassAcceptDefClass.class, SingleMemberClassWithDef.class); 1234 checkSerialization(SingleMemberEnumAcceptDefClass.class, SingleMemberEnumWithDef.class); 1235 1236 // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) 1237 checkSerialization(SingleMemberByteArrEmptyClass.class, SingleMemberByteArray.class); 1238 checkSerialization(SingleMemberShortArrEmptyClass.class, SingleMemberShortArray.class); 1239 checkSerialization(SingleMemberIntArrEmptyClass.class, SingleMemberIntArray.class); 1240 checkSerialization(SingleMemberLongArrEmptyClass.class, SingleMemberLongArray.class); 1241 checkSerialization(SingleMemberCharArrEmptyClass.class, SingleMemberCharArray.class); 1242 checkSerialization(SingleMemberFloatArrEmptyClass.class, SingleMemberFloatArray.class); 1243 checkSerialization(SingleMemberDoubleArrEmptyClass.class, SingleMemberDoubleArray.class); 1244 checkSerialization(SingleMemberBooleanArrEmptyClass.class, SingleMemberBooleanArray.class); 1245 checkSerialization(SingleMemberStringArrEmptyClass.class, SingleMemberStringArray.class); 1246 checkSerialization(SingleMemberClassArrEmptyClass.class, SingleMemberClassArray.class); 1247 checkSerialization(SingleMemberEnumArrEmptyClass.class, SingleMemberEnumArray.class); 1248 1249 // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) 1250 checkSerialization(SingleMemberByteArrOneClass.class, SingleMemberByteArray.class); 1251 checkSerialization(SingleMemberShortArrOneClass.class, SingleMemberShortArray.class); 1252 checkSerialization(SingleMemberIntArrOneClass.class, SingleMemberIntArray.class); 1253 checkSerialization(SingleMemberLongArrOneClass.class, SingleMemberLongArray.class); 1254 checkSerialization(SingleMemberCharArrOneClass.class, SingleMemberCharArray.class); 1255 checkSerialization(SingleMemberFloatArrOneClass.class, SingleMemberFloatArray.class); 1256 checkSerialization(SingleMemberDoubleArrOneClass.class, SingleMemberDoubleArray.class); 1257 checkSerialization(SingleMemberBooleanArrOneClass.class, SingleMemberBooleanArray.class); 1258 checkSerialization(SingleMemberStringArrOneClass.class, SingleMemberStringArray.class); 1259 checkSerialization(SingleMemberClassArrOneClass.class, SingleMemberClassArray.class); 1260 checkSerialization(SingleMemberEnumArrOneClass.class, SingleMemberEnumArray.class); 1261 1262 // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) 1263 checkSerialization(SingleMemberByteArrTwoClass.class, SingleMemberByteArray.class); 1264 checkSerialization(SingleMemberShortArrTwoClass.class, SingleMemberShortArray.class); 1265 checkSerialization(SingleMemberIntArrTwoClass.class, SingleMemberIntArray.class); 1266 checkSerialization(SingleMemberLongArrTwoClass.class, SingleMemberLongArray.class); 1267 checkSerialization(SingleMemberCharArrTwoClass.class, SingleMemberCharArray.class); 1268 checkSerialization(SingleMemberFloatArrTwoClass.class, SingleMemberFloatArray.class); 1269 checkSerialization(SingleMemberDoubleArrTwoClass.class, SingleMemberDoubleArray.class); 1270 checkSerialization(SingleMemberBooleanArrTwoClass.class, SingleMemberBooleanArray.class); 1271 checkSerialization(SingleMemberStringArrTwoClass.class, SingleMemberStringArray.class); 1272 checkSerialization(SingleMemberClassArrTwoClass.class, SingleMemberClassArray.class); 1273 checkSerialization(SingleMemberEnumArrTwoClass.class, SingleMemberEnumArray.class); 1274 1275 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE) 1276 checkSerialization(SingleMemberByteArrOvrdDefClass.class, SingleMemberByteArrayDef.class); 1277 checkSerialization(SingleMemberShortArrOvrdDefClass.class, SingleMemberShortArrayDef.class); 1278 checkSerialization(SingleMemberIntArrOvrdDefClass.class, SingleMemberIntArrayDef.class); 1279 checkSerialization(SingleMemberLongArrOvrdDefClass.class, SingleMemberLongArrayDef.class); 1280 checkSerialization(SingleMemberCharArrOvrdDefClass.class, SingleMemberCharArrayDef.class); 1281 checkSerialization(SingleMemberFloatArrOvrdDefClass.class, SingleMemberFloatArrayDef.class); 1282 checkSerialization(SingleMemberDoubleArrOvrdDefClass.class, SingleMemberDoubleArrayDef.class); 1283 checkSerialization(SingleMemberBooleanArrOvrdDefClass.class, SingleMemberBooleanArrayDef.class); 1284 checkSerialization(SingleMemberStringArrOvrdDefClass.class, SingleMemberStringArrayDef.class); 1285 checkSerialization(SingleMemberClassArrOvrdDefClass.class, SingleMemberClassArrayDef.class); 1286 checkSerialization(SingleMemberEnumArrOvrdDefClass.class, SingleMemberEnumArrayDef.class); 1287 1288 // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT) 1289 checkSerialization(SingleMemberByteArrAcceptDefClass.class, SingleMemberByteArrayDef.class); 1290 checkSerialization(SingleMemberShortArrAcceptDefClass.class, SingleMemberShortArrayDef.class); 1291 checkSerialization(SingleMemberIntArrAcceptDefClass.class, SingleMemberIntArrayDef.class); 1292 checkSerialization(SingleMemberLongArrAcceptDefClass.class, SingleMemberLongArrayDef.class); 1293 checkSerialization(SingleMemberCharArrAcceptDefClass.class, SingleMemberCharArrayDef.class); 1294 checkSerialization(SingleMemberFloatArrAcceptDefClass.class, SingleMemberFloatArrayDef.class); 1295 checkSerialization(SingleMemberDoubleArrAcceptDefClass.class, SingleMemberDoubleArrayDef.class); 1296 checkSerialization(SingleMemberBooleanArrAcceptDefClass.class, SingleMemberBooleanArrayDef.class); 1297 checkSerialization(SingleMemberStringArrAcceptDefClass.class, SingleMemberStringArrayDef.class); 1298 checkSerialization(SingleMemberClassArrAcceptDefClass.class, SingleMemberClassArrayDef.class); 1299 checkSerialization(SingleMemberEnumArrAcceptDefClass.class, SingleMemberEnumArrayDef.class); 1300 1301 // *** TESTS FOR ANNOTATION INHERITANCE AND ENUMERATING DECLARED ANNOTATIONS 1302 1303 // Inheritance tests 1304 checkInheritence(Grandpa.class, true, true); 1305 checkInheritence(Dad.class, true, false); 1306 checkInheritence(Son.class, true, true); 1307 1308 // Declared annotations tests 1309 checkDeclaredAnnotations(Grandpa.class, true, true); 1310 checkDeclaredAnnotations(Dad.class, false, false); 1311 checkDeclaredAnnotations(Son.class, false, true); 1312 1313 // Generate summary 1314 System.out.println("\n" + numTests + " tests completed"); 1315 if (failCount != 0) 1316 throw new Exception("Failure count: " + failCount); 1317 else 1318 System.out.println("Success."); 1319 } 1320 1321 static int failCount = 0; 1322 1323 private static void fail(String test) { 1324 System.out.println("Failure: " + test); 1325 failCount++; 1326 } 1327 1328 // ANNOTATION-VERIFICATION METHODS 1329 1330 // Scalar multi-member 1331 1332 static void checkScalarTypes(AnnotatedElement e) { 1333 try { 1334 checkScalarTypes(e.getAnnotation(ScalarTypes.class), e); 1335 } catch(Throwable t) { 1336 fail("ScalarTypes " + e + ": " + t); 1337 t.printStackTrace(); 1338 } 1339 } 1340 1341 static void checkScalarTypes(ScalarTypes st, AnnotatedElement e) throws Exception { 1342 numTests++; 1343 if (!(st.b() == 1 && 1344 st.s() == 2 && 1345 st.i() == 3 && 1346 st.l() == 4L && 1347 st.c() == '5' && 1348 st.f() == 6.0f && 1349 st.d() == 7.0 && 1350 st.bool() == true && 1351 st.str().equals("custom") && 1352 st.cls() == Map.class && 1353 st.e() == Stooge.MOE && 1354 st.a().x() == 1 && st.a().y() == 2)) 1355 fail("ScalarTypes" + e); 1356 } 1357 1358 static void checkScalarTypesOverrideDefault(AnnotatedElement e) { 1359 try { 1360 checkScalarTypesOverrideDefault(e.getAnnotation(ScalarTypesWithDefault.class), e); 1361 } catch(Throwable t) { 1362 fail("ScalarTypesOverrideDefaults" + e + ": " + t); 1363 } 1364 } 1365 1366 static void checkScalarTypesOverrideDefault(ScalarTypesWithDefault st, AnnotatedElement e) { 1367 numTests++; 1368 if (!(st.b() == 1 && 1369 st.s() == 2 && 1370 st.i() == 3 && 1371 st.l() == 4L && 1372 st.c() == '5' && 1373 st.f() == 6.0f && 1374 st.d() == 7.0 && 1375 st.bool() == true && 1376 st.str().equals("custom") && 1377 st.cls() == Map.class && 1378 st.e() == Stooge.MOE)) 1379 fail("ScalarTypesOverrideDefaults" + e); 1380 } 1381 1382 static void checkScalarTypesAcceptDefault(AnnotatedElement e) { 1383 try { 1384 checkScalarTypesAcceptDefault(e.getAnnotation(ScalarTypesWithDefault.class), e); 1385 } catch(Throwable t) { 1386 fail("ScalarTypesAcceptDefaults" + e + ": " + t); 1387 } 1388 } 1389 1390 static void checkScalarTypesAcceptDefault(ScalarTypesWithDefault st, AnnotatedElement e) { 1391 numTests++; 1392 if (!(st.b() == 11 && 1393 st.s() == 12 && 1394 st.i() == 13 && 1395 st.l() == 14L && 1396 st.c() == 'V' && 1397 st.f() == 16.0f && 1398 st.d() == 17.0 && 1399 st.bool() == false && 1400 st.str().equals("default") && 1401 st.cls() == Class.class && 1402 st.e() == Stooge.LARRY && 1403 st.a().x() == 11 && st.a().y() == 12)) 1404 fail("ScalarTypesAcceptDefaults" + e); 1405 } 1406 1407 // Array multi-member 1408 1409 static void checkArrayTypes0(AnnotatedElement e) { 1410 try { 1411 checkArrayTypes0(e.getAnnotation(ArrayTypes.class), e); 1412 } catch(Throwable t) { 1413 fail("ArrayTypes(Empty)" + e + ": " + t); 1414 } 1415 } 1416 1417 static void checkArrayTypes0(ArrayTypes at, AnnotatedElement e) { 1418 numTests++; 1419 if (!(at.b().length == 0 && 1420 at.s().length == 0 && 1421 at.i().length == 0 && 1422 at.l().length == 0 && 1423 at.c().length == 0 && 1424 at.f().length == 0 && 1425 at.d().length == 0 && 1426 at.bool().length == 0 && 1427 at.str().length == 0 && 1428 at.cls().length == 0 && 1429 at.e().length == 0 && 1430 at.a().length == 0)) { 1431 fail("ArrayTypes(Empty)" + e); 1432 } 1433 } 1434 1435 static void checkArrayTypes1(AnnotatedElement e) { 1436 try { 1437 checkArrayTypes1(e.getAnnotation(ArrayTypes.class), e); 1438 } catch(Throwable t) { 1439 fail("ArrayTypes(One element)" + e + ": " + t); 1440 } 1441 } 1442 1443 static void checkArrayTypes1(ArrayTypes at, AnnotatedElement e) { 1444 numTests++; 1445 if (!(at.b()[0] == 1 && 1446 at.s()[0] == 2 && 1447 at.i()[0] == 3 && 1448 at.l()[0] == 4L && 1449 at.c()[0] == '5' && 1450 at.f()[0] == 6.0f && 1451 at.d()[0] == 7.0 && 1452 at.bool()[0] == true && 1453 at.str()[0].equals("custom") && 1454 at.cls()[0] == Map.class && 1455 at.e()[0] == Stooge.MOE && 1456 at.a()[0].x() == 1 && at.a()[0].y() == 2 && 1457 1458 at.b().length==1 && at.s().length==1 && at.i().length==1 && 1459 at.l().length==1 && at.c().length==1 && at.d().length==1 && 1460 at.bool().length==1 && at.str().length==1 && 1461 at.cls().length==1 && at.cls().length==1 && at.a().length==1)) 1462 fail("ArrayTypes(One element)" + e); 1463 } 1464 1465 static void checkArrayTypes2(AnnotatedElement e) { 1466 try { 1467 checkArrayTypes2(e.getAnnotation(ArrayTypes.class), e); 1468 } catch(Throwable t) { 1469 fail("ArrayTypes(Two element)" + e + ": " + t); 1470 } 1471 } 1472 1473 static void checkArrayTypes2(ArrayTypes at, AnnotatedElement e) { 1474 numTests++; 1475 if (!(at.b()[0] == 1 && at.b()[1] == 2 && 1476 at.s()[0] == 2 && at.s()[1] == 3 && 1477 at.i()[0] == 3 && at.i()[1] == 4 && 1478 at.l()[0] == 4L && at.l()[1] == 5L && 1479 at.c()[0] == '5' && at.c()[1] == '6' && 1480 at.f()[0] == 6.0f && at.f()[1] == 7.0f && 1481 at.d()[0] == 7.0 && at.d()[1] == 8.0 && 1482 at.bool()[0] == true && at.bool()[1] == false && 1483 at.str()[0].equals("custom") && at.str()[1].equals("paint") && 1484 at.cls()[0] == Map.class && at.cls()[1] == Set.class && 1485 at.e()[0] == Stooge.MOE && at.e()[1] == Stooge.CURLY && 1486 at.a()[0].x() == 1 && at.a()[0].y() == 2 && at.a()[1].x() == 3 && at.a()[1].y() == 4 && 1487 1488 at.b().length==2 && at.s().length==2 && at.i().length==2 && 1489 at.l().length==2 && at.c().length==2 && at.d().length==2 && 1490 at.bool().length==2 && at.str().length==2 && 1491 at.cls().length==2 && at.cls().length==2 && at.a().length==2)) 1492 fail("ArrayTypes(Two element)" + e); 1493 } 1494 1495 static void checkArrayTypesOverrideDefault(AnnotatedElement e) { 1496 try { 1497 checkArrayTypesOverrideDefault(e.getAnnotation(ArrayTypesWithDefault.class), e); 1498 } catch(Throwable t) { 1499 fail("ArrayTypesOverrideDefault" + e + ": " + t); 1500 } 1501 } 1502 1503 static void checkArrayTypesOverrideDefault(ArrayTypesWithDefault at, AnnotatedElement e) { 1504 numTests++; 1505 if (!(at.b()[0] == 1 && 1506 at.s()[0] == 2 && 1507 at.i()[0] == 3 && 1508 at.l()[0] == 4L && 1509 at.c()[0] == '5' && 1510 at.f()[0] == 6.0f && 1511 at.d()[0] == 7.0 && 1512 at.bool()[0] == true && 1513 at.str()[0].equals("custom") && 1514 at.cls()[0] == Map.class && 1515 at.e()[0] == Stooge.MOE && 1516 at.a()[0].x() == 1 && at.a()[0].y() == 2 && 1517 1518 at.b().length==1 && at.s().length==1 && at.i().length==1 && 1519 at.l().length==1 && at.c().length==1 && at.d().length==1 && 1520 at.bool().length==1 && at.str().length==1 && 1521 at.cls().length==1 && at.cls().length==1)) 1522 fail("ArrayTypesOverrideDefault" + e); 1523 } 1524 1525 static void checkArrayTypesAcceptDefault(AnnotatedElement e) { 1526 try { 1527 checkArrayTypesAcceptDefault(e.getAnnotation(ArrayTypesWithDefault.class), e); 1528 } catch(Throwable t) { 1529 fail("ArrayTypesAcceptDefault" + e + ": " + t); 1530 } 1531 } 1532 1533 static void checkArrayTypesAcceptDefault(ArrayTypesWithDefault at, AnnotatedElement e) { 1534 numTests++; 1535 if (!(at.b()[0] == 11 && 1536 at.s()[0] == 12 && 1537 at.i()[0] == 13 && 1538 at.l()[0] == 14L && 1539 at.c()[0] == 'V' && 1540 at.f()[0] == 16.0f && 1541 at.d()[0] == 17.0 && 1542 at.bool()[0] == false && 1543 at.str()[0].equals("default") && 1544 at.cls()[0] == Class.class && 1545 at.e()[0] == Stooge.LARRY && 1546 at.a()[0].x() == 11 && at.a()[0].y() == 12 && 1547 1548 at.b().length==1 && at.s().length==1 && at.i().length==1 && 1549 at.l().length==1 && at.c().length==1 && at.d().length==1 && 1550 at.bool().length==1 && at.str().length==1 && 1551 at.cls().length==1 && at.cls().length==1)) 1552 fail("ArrayTypesAcceptDefault" + e); 1553 } 1554 1555 // Scalar multi-member for parameters 1556 1557 static void checkScalarTypesParam(Method m) { 1558 try { 1559 checkScalarTypes((ScalarTypes) m.getParameterAnnotations()[0][0], m); 1560 } catch(Throwable t) { 1561 fail("ScalarTypes" + m + ": " + t); 1562 } 1563 } 1564 1565 static void checkScalarTypesOverrideDefaultParam(Method m) { 1566 try { 1567 checkScalarTypesOverrideDefault((ScalarTypesWithDefault) m.getParameterAnnotations()[0][0], m); 1568 } catch(Throwable t) { 1569 fail("ScalarTypesOverrideDefaults" + m + ": " + t); 1570 } 1571 } 1572 1573 static void checkScalarTypesAcceptDefaultParam(Method m) { 1574 try { 1575 checkScalarTypesAcceptDefault((ScalarTypesWithDefault) m.getParameterAnnotations()[0][0], m); 1576 } catch(Throwable t) { 1577 fail("ScalarTypesAcceptDefaults" + m + ": " + t); 1578 } 1579 } 1580 1581 // Array multi-member for parameters 1582 1583 static void checkArrayTypes0Param(Method m) { 1584 try { 1585 checkArrayTypes0((ArrayTypes) m.getParameterAnnotations()[0][0], m); 1586 } catch(Throwable t) { 1587 fail("ArrayTypes(Empty)" + m + ": " + t); 1588 } 1589 } 1590 1591 static void checkArrayTypes1Param(Method m) { 1592 try { 1593 checkArrayTypes1((ArrayTypes) m.getParameterAnnotations()[0][0], m); 1594 } catch(Throwable t) { 1595 fail("ArrayTypes(One Element)" + m + ": " + t); 1596 } 1597 } 1598 1599 static void checkArrayTypes2Param(Method m) { 1600 try { 1601 checkArrayTypes2((ArrayTypes) m.getParameterAnnotations()[0][0], m); 1602 } catch(Throwable t) { 1603 fail("ArrayTypes(Two Elements)" + m + ": " + t); 1604 } 1605 } 1606 1607 static void checkArrayTypesOverrideDefaultParam(Method m) { 1608 try { 1609 checkArrayTypesOverrideDefault((ArrayTypesWithDefault) m.getParameterAnnotations()[0][0], m); 1610 } catch(Throwable t) { 1611 fail("ArrayTypesOverrideDefault" + m + ": " + t); 1612 } 1613 } 1614 1615 static void checkArrayTypesAcceptDefaultParam(Method m) { 1616 try { 1617 checkArrayTypesAcceptDefault((ArrayTypesWithDefault) m.getParameterAnnotations()[0][0], m); 1618 } catch(Throwable t) { 1619 fail("ArrayTypesAcceptDefault" + m + ": " + t); 1620 } 1621 } 1622 1623 // marker type on parameter 1624 static void checkMarkerParam(Method m) { 1625 try { 1626 checkMarker((Marker) m.getParameterAnnotations()[0][0], m); 1627 } catch(Throwable t) { 1628 fail("Marker" + m + ": " + t); 1629 } 1630 } 1631 1632 // single-member scalar types on parameter 1633 static void checkSingleMemberByteParam(Method m) { 1634 try { 1635 checkSingleMemberByte((SingleMemberByte) m.getParameterAnnotations()[0][0], m); 1636 } catch(Throwable t) { 1637 fail("SingleMemberByte" + m + ": " + t); 1638 } 1639 } 1640 1641 static void checkSingleMemberShortParam(Method m) { 1642 try { 1643 checkSingleMemberShort((SingleMemberShort) m.getParameterAnnotations()[0][0], m); 1644 } catch(Throwable t) { 1645 fail("SingleMemberShort" + m + ": " + t); 1646 } 1647 } 1648 1649 static void checkSingleMemberIntParam(Method m) { 1650 try { 1651 checkSingleMemberInt((SingleMemberInt) m.getParameterAnnotations()[0][0], m); 1652 } catch(Throwable t) { 1653 fail("SingleMemberInt" + m + ": " + t); 1654 } 1655 } 1656 1657 static void checkSingleMemberLongParam(Method m) { 1658 try { 1659 checkSingleMemberLong((SingleMemberLong) m.getParameterAnnotations()[0][0], m); 1660 } catch(Throwable t) { 1661 fail("SingleMemberLong" + m + ": " + t); 1662 } 1663 } 1664 1665 static void checkSingleMemberCharParam(Method m) { 1666 try { 1667 checkSingleMemberChar((SingleMemberChar) m.getParameterAnnotations()[0][0], m); 1668 } catch(Throwable t) { 1669 fail("SingleMemberChar" + m + ": " + t); 1670 } 1671 } 1672 1673 static void checkSingleMemberFloatParam(Method m) { 1674 try { 1675 checkSingleMemberFloat((SingleMemberFloat) m.getParameterAnnotations()[0][0], m); 1676 } catch(Throwable t) { 1677 fail("SingleMemberFloat" + m + ": " + t); 1678 } 1679 } 1680 1681 static void checkSingleMemberDoubleParam(Method m) { 1682 try { 1683 checkSingleMemberDouble((SingleMemberDouble) m.getParameterAnnotations()[0][0], m); 1684 } catch(Throwable t) { 1685 fail("SingleMemberDouble" + m + ": " + t); 1686 } 1687 } 1688 1689 static void checkSingleMemberBooleanParam(Method m) { 1690 try { 1691 checkSingleMemberBoolean((SingleMemberBoolean) m.getParameterAnnotations()[0][0], m); 1692 } catch(Throwable t) { 1693 fail("SingleMemberBoolean" + m + ": " + t); 1694 } 1695 } 1696 1697 static void checkSingleMemberStringParam(Method m) { 1698 try { 1699 checkSingleMemberString((SingleMemberString) m.getParameterAnnotations()[0][0], m); 1700 } catch(Throwable t) { 1701 fail("SingleMemberString" + m + ": " + t); 1702 } 1703 } 1704 1705 static void checkSingleMemberClassParam(Method m) { 1706 try { 1707 checkSingleMemberClass((SingleMemberClass) m.getParameterAnnotations()[0][0], m); 1708 } catch(Throwable t) { 1709 fail("SingleMemberClass" + m + ": " + t); 1710 } 1711 } 1712 1713 static void checkSingleMemberEnumParam(Method m) { 1714 try { 1715 checkSingleMemberEnum((SingleMemberEnum) m.getParameterAnnotations()[0][0], m); 1716 } catch(Throwable t) { 1717 fail("SingleMemberEnum" + m + ": " + t); 1718 } 1719 } 1720 1721 // single-member scalar types with default-override on parameter 1722 static void checkSingleMemberByteOvrdDefParam(Method m) { 1723 try { 1724 checkSingleMemberByteOvrdDef((SingleMemberByteWithDef) m.getParameterAnnotations()[0][0], m); 1725 } catch(Throwable t) { 1726 fail("SingleMemberByteOvrdDef" + m + ": " + t); 1727 } 1728 } 1729 1730 static void checkSingleMemberShortOvrdDefParam(Method m) { 1731 try { 1732 checkSingleMemberShortOvrdDef((SingleMemberShortWithDef) m.getParameterAnnotations()[0][0], m); 1733 } catch(Throwable t) { 1734 fail("SingleMemberShortOvrdDef" + m + ": " + t); 1735 } 1736 } 1737 1738 static void checkSingleMemberIntOvrdDefParam(Method m) { 1739 try { 1740 checkSingleMemberIntOvrdDef((SingleMemberIntWithDef) m.getParameterAnnotations()[0][0], m); 1741 } catch(Throwable t) { 1742 fail("SingleMemberIntOvrdDef" + m + ": " + t); 1743 } 1744 } 1745 1746 static void checkSingleMemberLongOvrdDefParam(Method m) { 1747 try { 1748 checkSingleMemberLongOvrdDef((SingleMemberLongWithDef) m.getParameterAnnotations()[0][0], m); 1749 } catch(Throwable t) { 1750 fail("SingleMemberLongOvrdDef" + m + ": " + t); 1751 } 1752 } 1753 1754 static void checkSingleMemberCharOvrdDefParam(Method m) { 1755 try { 1756 checkSingleMemberCharOvrdDef((SingleMemberCharWithDef) m.getParameterAnnotations()[0][0], m); 1757 } catch(Throwable t) { 1758 fail("SingleMemberCharOvrdDef" + m + ": " + t); 1759 } 1760 } 1761 1762 static void checkSingleMemberFloatOvrdDefParam(Method m) { 1763 try { 1764 checkSingleMemberFloatOvrdDef((SingleMemberFloatWithDef) m.getParameterAnnotations()[0][0], m); 1765 } catch(Throwable t) { 1766 fail("SingleMemberFloatOvrdDef" + m + ": " + t); 1767 } 1768 } 1769 1770 static void checkSingleMemberDoubleOvrdDefParam(Method m) { 1771 try { 1772 checkSingleMemberDoubleOvrdDef((SingleMemberDoubleWithDef) m.getParameterAnnotations()[0][0], m); 1773 } catch(Throwable t) { 1774 fail("SingleMemberDoubleOvrdDef" + m + ": " + t); 1775 } 1776 } 1777 1778 static void checkSingleMemberBooleanOvrdDefParam(Method m) { 1779 try { 1780 checkSingleMemberBooleanOvrdDef((SingleMemberBooleanWithDef) m.getParameterAnnotations()[0][0], m); 1781 } catch(Throwable t) { 1782 fail("SingleMemberBooleanOvrdDef" + m + ": " + t); 1783 } 1784 } 1785 1786 static void checkSingleMemberStringOvrdDefParam(Method m) { 1787 try { 1788 checkSingleMemberStringOvrdDef((SingleMemberStringWithDef) m.getParameterAnnotations()[0][0], m); 1789 } catch(Throwable t) { 1790 fail("SingleMemberStringOvrdDef" + m + ": " + t); 1791 } 1792 } 1793 1794 static void checkSingleMemberClassOvrdDefParam(Method m) { 1795 try { 1796 checkSingleMemberClassOvrdDef((SingleMemberClassWithDef) m.getParameterAnnotations()[0][0], m); 1797 } catch(Throwable t) { 1798 fail("SingleMemberClassOvrdDef" + m + ": " + t); 1799 } 1800 } 1801 1802 static void checkSingleMemberEnumOvrdDefParam(Method m) { 1803 try { 1804 checkSingleMemberEnumOvrdDef((SingleMemberEnumWithDef) m.getParameterAnnotations()[0][0], m); 1805 } catch(Throwable t) { 1806 fail("SingleMemberEnumOvrdDef" + m + ": " + t); 1807 } 1808 } 1809 1810 // single-member scalar types with default-accept on PARAMETER 1811 static void checkSingleMemberByteAcceptDefParam(Method m) { 1812 try { 1813 checkSingleMemberByteAcceptDef((SingleMemberByteWithDef) m.getParameterAnnotations()[0][0], m); 1814 } catch(Throwable t) { 1815 fail("SingleMemberByteAcceptDef" + m + ": " + t); 1816 } 1817 } 1818 1819 static void checkSingleMemberShortAcceptDefParam(Method m) { 1820 try { 1821 checkSingleMemberShortAcceptDef((SingleMemberShortWithDef) m.getParameterAnnotations()[0][0], m); 1822 } catch(Throwable t) { 1823 fail("SingleMemberShortAcceptDef" + m + ": " + t); 1824 } 1825 } 1826 1827 static void checkSingleMemberIntAcceptDefParam(Method m) { 1828 try { 1829 checkSingleMemberIntAcceptDef((SingleMemberIntWithDef) m.getParameterAnnotations()[0][0], m); 1830 } catch(Throwable t) { 1831 fail("SingleMemberIntAcceptDef" + m + ": " + t); 1832 } 1833 } 1834 1835 static void checkSingleMemberLongAcceptDefParam(Method m) { 1836 try { 1837 checkSingleMemberLongAcceptDef((SingleMemberLongWithDef) m.getParameterAnnotations()[0][0], m); 1838 } catch(Throwable t) { 1839 fail("SingleMemberLongAcceptDef" + m + ": " + t); 1840 } 1841 } 1842 1843 static void checkSingleMemberCharAcceptDefParam(Method m) { 1844 try { 1845 checkSingleMemberCharAcceptDef((SingleMemberCharWithDef) m.getParameterAnnotations()[0][0], m); 1846 } catch(Throwable t) { 1847 fail("SingleMemberCharAcceptDef" + m + ": " + t); 1848 } 1849 } 1850 1851 static void checkSingleMemberFloatAcceptDefParam(Method m) { 1852 try { 1853 checkSingleMemberFloatAcceptDef((SingleMemberFloatWithDef) m.getParameterAnnotations()[0][0], m); 1854 } catch(Throwable t) { 1855 fail("SingleMemberFloatAcceptDef" + m + ": " + t); 1856 } 1857 } 1858 1859 static void checkSingleMemberDoubleAcceptDefParam(Method m) { 1860 try { 1861 checkSingleMemberDoubleAcceptDef((SingleMemberDoubleWithDef) m.getParameterAnnotations()[0][0], m); 1862 } catch(Throwable t) { 1863 fail("SingleMemberDoubleAcceptDef" + m + ": " + t); 1864 } 1865 } 1866 1867 static void checkSingleMemberBooleanAcceptDefParam(Method m) { 1868 try { 1869 checkSingleMemberBooleanAcceptDef((SingleMemberBooleanWithDef) m.getParameterAnnotations()[0][0], m); 1870 } catch(Throwable t) { 1871 fail("SingleMemberBooleanAcceptDef" + m + ": " + t); 1872 } 1873 } 1874 1875 static void checkSingleMemberStringAcceptDefParam(Method m) { 1876 try { 1877 checkSingleMemberStringAcceptDef((SingleMemberStringWithDef) m.getParameterAnnotations()[0][0], m); 1878 } catch(Throwable t) { 1879 fail("SingleMemberStringAcceptDef" + m + ": " + t); 1880 } 1881 } 1882 1883 static void checkSingleMemberClassAcceptDefParam(Method m) { 1884 try { 1885 checkSingleMemberClassAcceptDef((SingleMemberClassWithDef) m.getParameterAnnotations()[0][0], m); 1886 } catch(Throwable t) { 1887 fail("SingleMemberClassAcceptDef" + m + ": " + t); 1888 } 1889 } 1890 1891 static void checkSingleMemberEnumAcceptDefParam(Method m) { 1892 try { 1893 checkSingleMemberEnumAcceptDef((SingleMemberEnumWithDef) m.getParameterAnnotations()[0][0], m); 1894 } catch(Throwable t) { 1895 fail("SingleMemberEnumAcceptDef" + m + ": " + t); 1896 } 1897 } 1898 1899 // single-member array types (empty array) parameter 1900 static void checkSingleMemberByteArrEmptyParam(Method m) { 1901 try { 1902 checkSingleMemberByteArrEmpty((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m); 1903 } catch(Throwable t) { 1904 fail("SingleMemberByteArrEmpty" + m + ": " + t); 1905 } 1906 } 1907 1908 static void checkSingleMemberShortArrEmptyParam(Method m) { 1909 try { 1910 checkSingleMemberShortArrEmpty((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m); 1911 } catch(Throwable t) { 1912 fail("SingleMemberShortArrEmpty" + m + ": " + t); 1913 } 1914 } 1915 1916 static void checkSingleMemberIntArrEmptyParam(Method m) { 1917 try { 1918 checkSingleMemberIntArrEmpty((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m); 1919 } catch(Throwable t) { 1920 fail("SingleMemberIntArrEmpty" + m + ": " + t); 1921 } 1922 } 1923 1924 static void checkSingleMemberLongArrEmptyParam(Method m) { 1925 try { 1926 checkSingleMemberLongArrEmpty((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m); 1927 } catch(Throwable t) { 1928 fail("SingleMemberLongArrEmpty" + m + ": " + t); 1929 } 1930 } 1931 1932 static void checkSingleMemberCharArrEmptyParam(Method m) { 1933 try { 1934 checkSingleMemberCharArrEmpty((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m); 1935 } catch(Throwable t) { 1936 fail("SingleMemberCharArrEmpty" + m + ": " + t); 1937 } 1938 } 1939 1940 static void checkSingleMemberFloatArrEmptyParam(Method m) { 1941 try { 1942 checkSingleMemberFloatArrEmpty((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m); 1943 } catch(Throwable t) { 1944 fail("SingleMemberFloatArrEmpty" + m + ": " + t); 1945 } 1946 } 1947 1948 static void checkSingleMemberDoubleArrEmptyParam(Method m) { 1949 try { 1950 checkSingleMemberDoubleArrEmpty((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m); 1951 } catch(Throwable t) { 1952 fail("SingleMemberDoubleArrEmpty" + m + ": " + t); 1953 } 1954 } 1955 1956 static void checkSingleMemberBooleanArrEmptyParam(Method m) { 1957 try { 1958 checkSingleMemberBooleanArrEmpty((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m); 1959 } catch(Throwable t) { 1960 fail("SingleMemberBooleanArrEmpty" + m + ": " + t); 1961 } 1962 } 1963 1964 static void checkSingleMemberStringArrEmptyParam(Method m) { 1965 try { 1966 checkSingleMemberStringArrEmpty((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m); 1967 } catch(Throwable t) { 1968 fail("SingleMemberStringArrEmpty" + m + ": " + t); 1969 } 1970 } 1971 1972 static void checkSingleMemberClassArrEmptyParam(Method m) { 1973 try { 1974 checkSingleMemberClassArrEmpty((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m); 1975 } catch(Throwable t) { 1976 fail("SingleMemberClassArrEmpty" + m + ": " + t); 1977 } 1978 } 1979 1980 static void checkSingleMemberEnumArrEmptyParam(Method m) { 1981 try { 1982 checkSingleMemberEnumArrEmpty((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m); 1983 } catch(Throwable t) { 1984 fail("SingleMemberEnumArrEmpty" + m + ": " + t); 1985 } 1986 } 1987 1988 // single-member array types (one-element array) on parameter 1989 static void checkSingleMemberByteArrOneParam(Method m) { 1990 try { 1991 checkSingleMemberByteArrOne((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m); 1992 } catch(Throwable t) { 1993 fail("SingleMemberByteArrOne" + m + ": " + t); 1994 } 1995 } 1996 1997 static void checkSingleMemberShortArrOneParam(Method m) { 1998 try { 1999 checkSingleMemberShortArrOne((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m); 2000 } catch(Throwable t) { 2001 fail("SingleMemberShortArrOne" + m + ": " + t); 2002 } 2003 } 2004 2005 static void checkSingleMemberIntArrOneParam(Method m) { 2006 try { 2007 checkSingleMemberIntArrOne((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m); 2008 } catch(Throwable t) { 2009 fail("SingleMemberIntArrOne" + m + ": " + t); 2010 } 2011 } 2012 2013 static void checkSingleMemberLongArrOneParam(Method m) { 2014 try { 2015 checkSingleMemberLongArrOne((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m); 2016 } catch(Throwable t) { 2017 fail("SingleMemberLongArrOne" + m + ": " + t); 2018 } 2019 } 2020 2021 static void checkSingleMemberCharArrOneParam(Method m) { 2022 try { 2023 checkSingleMemberCharArrOne((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m); 2024 } catch(Throwable t) { 2025 fail("SingleMemberCharArrOne" + m + ": " + t); 2026 } 2027 } 2028 2029 static void checkSingleMemberFloatArrOneParam(Method m) { 2030 try { 2031 checkSingleMemberFloatArrOne((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m); 2032 } catch(Throwable t) { 2033 fail("SingleMemberFloatArrOne" + m + ": " + t); 2034 } 2035 } 2036 2037 static void checkSingleMemberDoubleArrOneParam(Method m) { 2038 try { 2039 checkSingleMemberDoubleArrOne((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m); 2040 } catch(Throwable t) { 2041 fail("SingleMemberDoubleArrOne" + m + ": " + t); 2042 } 2043 } 2044 2045 static void checkSingleMemberBooleanArrOneParam(Method m) { 2046 try { 2047 checkSingleMemberBooleanArrOne((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m); 2048 } catch(Throwable t) { 2049 fail("SingleMemberBooleanArrOne" + m + ": " + t); 2050 } 2051 } 2052 2053 static void checkSingleMemberStringArrOneParam(Method m) { 2054 try { 2055 checkSingleMemberStringArrOne((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m); 2056 } catch(Throwable t) { 2057 fail("SingleMemberStringArrOne" + m + ": " + t); 2058 } 2059 } 2060 2061 static void checkSingleMemberClassArrOneParam(Method m) { 2062 try { 2063 checkSingleMemberClassArrOne((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m); 2064 } catch(Throwable t) { 2065 fail("SingleMemberClassArrOne" + m + ": " + t); 2066 } 2067 } 2068 2069 static void checkSingleMemberEnumArrOneParam(Method m) { 2070 try { 2071 checkSingleMemberEnumArrOne((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m); 2072 } catch(Throwable t) { 2073 fail("SingleMemberEnumArrOne" + m + ": " + t); 2074 } 2075 } 2076 2077 // single-member array types (two-element array) on parameter 2078 static void checkSingleMemberByteArrTwoParam(Method m) { 2079 try { 2080 checkSingleMemberByteArrTwo((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m); 2081 } catch(Throwable t) { 2082 fail("SingleMemberByteArrTwo" + m + ": " + t); 2083 } 2084 } 2085 2086 static void checkSingleMemberShortArrTwoParam(Method m) { 2087 try { 2088 checkSingleMemberShortArrTwo((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m); 2089 } catch(Throwable t) { 2090 fail("SingleMemberShortArrTwo" + m + ": " + t); 2091 } 2092 } 2093 2094 static void checkSingleMemberIntArrTwoParam(Method m) { 2095 try { 2096 checkSingleMemberIntArrTwo((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m); 2097 } catch(Throwable t) { 2098 fail("SingleMemberIntArrTwo" + m + ": " + t); 2099 } 2100 } 2101 2102 static void checkSingleMemberLongArrTwoParam(Method m) { 2103 try { 2104 checkSingleMemberLongArrTwo((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m); 2105 } catch(Throwable t) { 2106 fail("SingleMemberLongArrTwo" + m + ": " + t); 2107 } 2108 } 2109 2110 static void checkSingleMemberCharArrTwoParam(Method m) { 2111 try { 2112 checkSingleMemberCharArrTwo((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m); 2113 } catch(Throwable t) { 2114 fail("SingleMemberCharArrTwo" + m + ": " + t); 2115 } 2116 } 2117 2118 static void checkSingleMemberFloatArrTwoParam(Method m) { 2119 try { 2120 checkSingleMemberFloatArrTwo((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m); 2121 } catch(Throwable t) { 2122 fail("SingleMemberFloatArrTwo" + m + ": " + t); 2123 } 2124 } 2125 2126 static void checkSingleMemberDoubleArrTwoParam(Method m) { 2127 try { 2128 checkSingleMemberDoubleArrTwo((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m); 2129 } catch(Throwable t) { 2130 fail("SingleMemberDoubleArrTwo" + m + ": " + t); 2131 } 2132 } 2133 2134 static void checkSingleMemberBooleanArrTwoParam(Method m) { 2135 try { 2136 checkSingleMemberBooleanArrTwo((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m); 2137 } catch(Throwable t) { 2138 fail("SingleMemberBooleanArrTwo" + m + ": " + t); 2139 } 2140 } 2141 2142 static void checkSingleMemberStringArrTwoParam(Method m) { 2143 try { 2144 checkSingleMemberStringArrTwo((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m); 2145 } catch(Throwable t) { 2146 fail("SingleMemberStringArrTwo" + m + ": " + t); 2147 } 2148 } 2149 2150 static void checkSingleMemberClassArrTwoParam(Method m) { 2151 try { 2152 checkSingleMemberClassArrTwo((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m); 2153 } catch(Throwable t) { 2154 fail("SingleMemberClassArrTwo" + m + ": " + t); 2155 } 2156 } 2157 2158 static void checkSingleMemberEnumArrTwoParam(Method m) { 2159 try { 2160 checkSingleMemberEnumArrTwo((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m); 2161 } catch(Throwable t) { 2162 fail("SingleMemberEnumArrTwo" + m + ": " + t); 2163 } 2164 } 2165 2166 // single-member array types with default (override)on parameter 2167 static void checkSingleMemberByteArrOvrdDefParam(Method m) { 2168 try { 2169 checkSingleMemberByteArrOvrdDef((SingleMemberByteArrayDef) m.getParameterAnnotations()[0][0], m); 2170 } catch(Throwable t) { 2171 fail("SingleMemberByteArrOvrdDef" + m + ": " + t); 2172 } 2173 } 2174 2175 static void checkSingleMemberShortArrOvrdDefParam(Method m) { 2176 try { 2177 checkSingleMemberShortArrOvrdDef((SingleMemberShortArrayDef) m.getParameterAnnotations()[0][0], m); 2178 } catch(Throwable t) { 2179 fail("SingleMemberShortArrOvrdDef" + m + ": " + t); 2180 } 2181 } 2182 2183 static void checkSingleMemberIntArrOvrdDefParam(Method m) { 2184 try { 2185 checkSingleMemberIntArrOvrdDef((SingleMemberIntArrayDef) m.getParameterAnnotations()[0][0], m); 2186 } catch(Throwable t) { 2187 fail("SingleMemberIntArrOvrdDef" + m + ": " + t); 2188 } 2189 } 2190 2191 static void checkSingleMemberLongArrOvrdDefParam(Method m) { 2192 try { 2193 checkSingleMemberLongArrOvrdDef((SingleMemberLongArrayDef) m.getParameterAnnotations()[0][0], m); 2194 } catch(Throwable t) { 2195 fail("SingleMemberLongArrOvrdDef" + m + ": " + t); 2196 } 2197 } 2198 2199 static void checkSingleMemberCharArrOvrdDefParam(Method m) { 2200 try { 2201 checkSingleMemberCharArrOvrdDef((SingleMemberCharArrayDef) m.getParameterAnnotations()[0][0], m); 2202 } catch(Throwable t) { 2203 fail("SingleMemberCharArrOvrdDef" + m + ": " + t); 2204 } 2205 } 2206 2207 static void checkSingleMemberFloatArrOvrdDefParam(Method m) { 2208 try { 2209 checkSingleMemberFloatArrOvrdDef((SingleMemberFloatArrayDef) m.getParameterAnnotations()[0][0], m); 2210 } catch(Throwable t) { 2211 fail("SingleMemberFloatArrOvrdDef" + m + ": " + t); 2212 } 2213 } 2214 2215 static void checkSingleMemberDoubleArrOvrdDefParam(Method m) { 2216 try { 2217 checkSingleMemberDoubleArrOvrdDef((SingleMemberDoubleArrayDef) m.getParameterAnnotations()[0][0], m); 2218 } catch(Throwable t) { 2219 fail("SingleMemberDoubleArrOvrdDef" + m + ": " + t); 2220 } 2221 } 2222 2223 static void checkSingleMemberBooleanArrOvrdDefParam(Method m) { 2224 try { 2225 checkSingleMemberBooleanArrOvrdDef((SingleMemberBooleanArrayDef) m.getParameterAnnotations()[0][0], m); 2226 } catch(Throwable t) { 2227 fail("SingleMemberBooleanArrOvrdDef" + m + ": " + t); 2228 } 2229 } 2230 2231 static void checkSingleMemberStringArrOvrdDefParam(Method m) { 2232 try { 2233 checkSingleMemberStringArrOvrdDef((SingleMemberStringArrayDef) m.getParameterAnnotations()[0][0], m); 2234 } catch(Throwable t) { 2235 fail("SingleMemberStringArrOvrdDef" + m + ": " + t); 2236 } 2237 } 2238 2239 static void checkSingleMemberClassArrOvrdDefParam(Method m) { 2240 try { 2241 checkSingleMemberClassArrOvrdDef((SingleMemberClassArrayDef) m.getParameterAnnotations()[0][0], m); 2242 } catch(Throwable t) { 2243 fail("SingleMemberClassArrOvrdDef" + m + ": " + t); 2244 } 2245 } 2246 2247 static void checkSingleMemberEnumArrOvrdDefParam(Method m) { 2248 try { 2249 checkSingleMemberEnumArrOvrdDef((SingleMemberEnumArrayDef) m.getParameterAnnotations()[0][0], m); 2250 } catch(Throwable t) { 2251 fail("SingleMemberEnumArrOvrdDef" + m + ": " + t); 2252 } 2253 } 2254 2255 // single-member array types with default (accept)on parameter 2256 static void checkSingleMemberByteArrAcceptDefParam(Method m) { 2257 try { 2258 checkSingleMemberByteArrAcceptDef((SingleMemberByteArrayDef) m.getParameterAnnotations()[0][0], m); 2259 } catch(Throwable t) { 2260 fail("SingleMemberByteArrAcceptDef" + m + ": " + t); 2261 } 2262 } 2263 2264 static void checkSingleMemberShortArrAcceptDefParam(Method m) { 2265 try { 2266 checkSingleMemberShortArrAcceptDef((SingleMemberShortArrayDef) m.getParameterAnnotations()[0][0], m); 2267 } catch(Throwable t) { 2268 fail("SingleMemberShortArrAcceptDef" + m + ": " + t); 2269 } 2270 } 2271 2272 static void checkSingleMemberIntArrAcceptDefParam(Method m) { 2273 try { 2274 checkSingleMemberIntArrAcceptDef((SingleMemberIntArrayDef) m.getParameterAnnotations()[0][0], m); 2275 } catch(Throwable t) { 2276 fail("SingleMemberIntArrAcceptDef" + m + ": " + t); 2277 } 2278 } 2279 2280 static void checkSingleMemberLongArrAcceptDefParam(Method m) { 2281 try { 2282 checkSingleMemberLongArrAcceptDef((SingleMemberLongArrayDef) m.getParameterAnnotations()[0][0], m); 2283 } catch(Throwable t) { 2284 fail("SingleMemberLongArrAcceptDef" + m + ": " + t); 2285 } 2286 } 2287 2288 static void checkSingleMemberCharArrAcceptDefParam(Method m) { 2289 try { 2290 checkSingleMemberCharArrAcceptDef((SingleMemberCharArrayDef) m.getParameterAnnotations()[0][0], m); 2291 } catch(Throwable t) { 2292 fail("SingleMemberCharArrAcceptDef" + m + ": " + t); 2293 } 2294 } 2295 2296 static void checkSingleMemberFloatArrAcceptDefParam(Method m) { 2297 try { 2298 checkSingleMemberFloatArrAcceptDef((SingleMemberFloatArrayDef) m.getParameterAnnotations()[0][0], m); 2299 } catch(Throwable t) { 2300 fail("SingleMemberFloatArrAcceptDef" + m + ": " + t); 2301 } 2302 } 2303 2304 static void checkSingleMemberDoubleArrAcceptDefParam(Method m) { 2305 try { 2306 checkSingleMemberDoubleArrAcceptDef((SingleMemberDoubleArrayDef) m.getParameterAnnotations()[0][0], m); 2307 } catch(Throwable t) { 2308 fail("SingleMemberDoubleArrAcceptDef" + m + ": " + t); 2309 } 2310 } 2311 2312 static void checkSingleMemberBooleanArrAcceptDefParam(Method m) { 2313 try { 2314 checkSingleMemberBooleanArrAcceptDef((SingleMemberBooleanArrayDef) m.getParameterAnnotations()[0][0], m); 2315 } catch(Throwable t) { 2316 fail("SingleMemberBooleanArrAcceptDef" + m + ": " + t); 2317 } 2318 } 2319 2320 static void checkSingleMemberStringArrAcceptDefParam(Method m) { 2321 try { 2322 checkSingleMemberStringArrAcceptDef((SingleMemberStringArrayDef) m.getParameterAnnotations()[0][0], m); 2323 } catch(Throwable t) { 2324 fail("SingleMemberStringArrAcceptDef" + m + ": " + t); 2325 } 2326 } 2327 2328 static void checkSingleMemberClassArrAcceptDefParam(Method m) { 2329 try { 2330 checkSingleMemberClassArrAcceptDef((SingleMemberClassArrayDef) m.getParameterAnnotations()[0][0], m); 2331 } catch(Throwable t) { 2332 fail("SingleMemberClassArrAcceptDef" + m + ": " + t); 2333 } 2334 } 2335 2336 static void checkSingleMemberEnumArrAcceptDefParam(Method m) { 2337 try { 2338 checkSingleMemberEnumArrAcceptDef((SingleMemberEnumArrayDef) m.getParameterAnnotations()[0][0], m); 2339 } catch(Throwable t) { 2340 fail("SingleMemberEnumArrAcceptDef" + m + ": " + t); 2341 } 2342 } 2343 2344 // Marker 2345 static void checkMarker(AnnotatedElement e) { 2346 checkMarker(e.getAnnotation(Marker.class), e); 2347 } 2348 static void checkMarker(Marker m, AnnotatedElement e) { 2349 numTests++; 2350 try { 2351 if (m == null) fail("Marker " + e); 2352 } catch(Throwable t) { 2353 fail("Marker " + e + ": " + t); 2354 } 2355 } 2356 2357 // Single-member 2358 2359 static void checkSingleMemberByte(AnnotatedElement e) { 2360 checkSingleMemberByte(e.getAnnotation(SingleMemberByte.class), e); 2361 } 2362 static void checkSingleMemberByte(SingleMemberByte a, AnnotatedElement e) { 2363 numTests++; 2364 try { 2365 if (a.value() != 1) fail("SingleMemberByte " + e + " = " + a.value()); 2366 } catch(Throwable t) { 2367 fail("SingleMemberByte " + e + ": " + t); 2368 } 2369 } 2370 2371 static void checkSingleMemberShort(AnnotatedElement e) { 2372 checkSingleMemberShort(e.getAnnotation(SingleMemberShort.class), e); 2373 } 2374 static void checkSingleMemberShort(SingleMemberShort a, AnnotatedElement e) { 2375 numTests++; 2376 try { 2377 if (a.value() != 2) fail("SingleMemberShort " + e + " = " + a.value()); 2378 } catch(Throwable t) { 2379 fail("SingleMemberShort " + e + ": " + t); 2380 } 2381 } 2382 2383 static void checkSingleMemberInt(AnnotatedElement e) { 2384 checkSingleMemberInt(e.getAnnotation(SingleMemberInt.class), e); 2385 } 2386 static void checkSingleMemberInt(SingleMemberInt a, AnnotatedElement e) { 2387 numTests++; 2388 try { 2389 if (a.value() != 3) fail("SingleMemberInt " + e + " = " + a.value()); 2390 } catch(Throwable t) { 2391 fail("SingleMemberInt " + e + ": " + t); 2392 } 2393 } 2394 2395 static void checkSingleMemberLong(AnnotatedElement e) { 2396 checkSingleMemberLong(e.getAnnotation(SingleMemberLong.class), e); 2397 } 2398 static void checkSingleMemberLong(SingleMemberLong a, AnnotatedElement e) { 2399 numTests++; 2400 try { 2401 if (a.value() != 4L) fail("SingleMemberLong " + e + " = " + a.value()); 2402 } catch(Throwable t) { 2403 fail("SingleMemberLong " + e + ": " + t); 2404 } 2405 } 2406 2407 static void checkSingleMemberChar(AnnotatedElement e) { 2408 checkSingleMemberChar(e.getAnnotation(SingleMemberChar.class), e); 2409 } 2410 static void checkSingleMemberChar(SingleMemberChar a, AnnotatedElement e) { 2411 numTests++; 2412 try { 2413 if (a.value() != '5') fail("SingleMemberChar " + e + " = " + a.value()); 2414 } catch(Throwable t) { 2415 fail("SingleMemberChar " + e + ": " + t); 2416 } 2417 } 2418 2419 static void checkSingleMemberFloat(AnnotatedElement e) { 2420 checkSingleMemberFloat(e.getAnnotation(SingleMemberFloat.class), e); 2421 } 2422 static void checkSingleMemberFloat(SingleMemberFloat a, AnnotatedElement e) { 2423 numTests++; 2424 try { 2425 if (a.value() != 6.0f) fail("SingleMemberFloat " + e + " = " + a.value()); 2426 } catch(Throwable t) { 2427 fail("SingleMemberFloat " + e + ": " + t); 2428 } 2429 } 2430 2431 static void checkSingleMemberDouble(AnnotatedElement e) { 2432 checkSingleMemberDouble(e.getAnnotation(SingleMemberDouble.class), e); 2433 } 2434 static void checkSingleMemberDouble(SingleMemberDouble a, AnnotatedElement e) { 2435 numTests++; 2436 try { 2437 if (a.value() != 7.0) fail("SingleMemberDouble " + e + " = " + a.value()); 2438 } catch(Throwable t) { 2439 fail("SingleMemberDouble " + e + ": " + t); 2440 } 2441 } 2442 2443 static void checkSingleMemberBoolean(AnnotatedElement e) { 2444 checkSingleMemberBoolean(e.getAnnotation(SingleMemberBoolean.class), e); 2445 } 2446 static void checkSingleMemberBoolean(SingleMemberBoolean a, AnnotatedElement e) { 2447 numTests++; 2448 try { 2449 if (!a.value()) fail("SingleMemberBoolean " + e + " = " + a.value()); 2450 } catch(Throwable t) { 2451 fail("SingleMemberBoolean " + e + ": " + t); 2452 } 2453 } 2454 2455 static void checkSingleMemberString(AnnotatedElement e) { 2456 checkSingleMemberString(e.getAnnotation(SingleMemberString.class), e); 2457 } 2458 static void checkSingleMemberString(SingleMemberString a, AnnotatedElement e) { 2459 numTests++; 2460 try { 2461 if (!(a.value().equals("custom"))) fail("SingleMemberString " + e + " = " + a.value()); 2462 } catch(Throwable t) { 2463 fail("SingleMemberString " + e + ": " + t); 2464 } 2465 } 2466 2467 static void checkSingleMemberClass(AnnotatedElement e) { 2468 checkSingleMemberClass(e.getAnnotation(SingleMemberClass.class), e); 2469 } 2470 static void checkSingleMemberClass(SingleMemberClass a, AnnotatedElement e) { 2471 numTests++; 2472 try { 2473 if (a.value() != Map.class) fail("SingleMemberClass " + e + " = " + a.value()); 2474 } catch(Throwable t) { 2475 fail("SingleMemberClass " + e + ": " + t); 2476 } 2477 } 2478 2479 static void checkSingleMemberEnum(AnnotatedElement e) { 2480 checkSingleMemberEnum(e.getAnnotation(SingleMemberEnum.class), e); 2481 } 2482 static void checkSingleMemberEnum(SingleMemberEnum a, AnnotatedElement e) { 2483 numTests++; 2484 try { 2485 if (a.value() != Stooge.MOE) fail("SingleMemberEnum " + e + " = " + a.value()); 2486 } catch(Throwable t) { 2487 fail("SingleMemberEnum " + e + ": " + t); 2488 } 2489 } 2490 2491 // Single-member with default (Override) 2492 2493 static void checkSingleMemberByteOvrdDef(AnnotatedElement e) { 2494 checkSingleMemberByteOvrdDef(e.getAnnotation(SingleMemberByteWithDef.class), e); 2495 } 2496 static void checkSingleMemberByteOvrdDef(SingleMemberByteWithDef a, AnnotatedElement e) { 2497 numTests++; 2498 try { 2499 if (a.value() != 1) fail("SingleMemberByteOvrdDef " + e + " = " + a.value()); 2500 } catch(Throwable t) { 2501 fail("SingleMemberByteOvrdDef " + e + ": " + t); 2502 } 2503 } 2504 2505 static void checkSingleMemberShortOvrdDef(AnnotatedElement e) { 2506 checkSingleMemberShortOvrdDef(e.getAnnotation(SingleMemberShortWithDef.class), e); 2507 } 2508 static void checkSingleMemberShortOvrdDef(SingleMemberShortWithDef a, AnnotatedElement e) { 2509 numTests++; 2510 try { 2511 if (a.value() != 2) fail("SingleMemberShortOvrdDef " + e + " = " + a.value()); 2512 } catch(Throwable t) { 2513 fail("SingleMemberShortOvrdDef " + e + ": " + t); 2514 } 2515 } 2516 2517 static void checkSingleMemberIntOvrdDef(AnnotatedElement e) { 2518 checkSingleMemberIntOvrdDef(e.getAnnotation(SingleMemberIntWithDef.class), e); 2519 } 2520 static void checkSingleMemberIntOvrdDef(SingleMemberIntWithDef a, AnnotatedElement e) { 2521 numTests++; 2522 try { 2523 if (a.value() != 3) fail("SingleMemberIntOvrdDef " + e + " = " + a.value()); 2524 } catch(Throwable t) { 2525 fail("SingleMemberIntOvrdDef " + e + ": " + t); 2526 } 2527 } 2528 2529 static void checkSingleMemberLongOvrdDef(AnnotatedElement e) { 2530 checkSingleMemberLongOvrdDef(e.getAnnotation(SingleMemberLongWithDef.class), e); 2531 } 2532 static void checkSingleMemberLongOvrdDef(SingleMemberLongWithDef a, AnnotatedElement e) { 2533 numTests++; 2534 try { 2535 if (a.value() != 4L) fail("SingleMemberLongOvrdDef " + e + " = " + a.value()); 2536 } catch(Throwable t) { 2537 fail("SingleMemberLongOvrdDef " + e + ": " + t); 2538 } 2539 } 2540 2541 static void checkSingleMemberCharOvrdDef(AnnotatedElement e) { 2542 checkSingleMemberCharOvrdDef(e.getAnnotation(SingleMemberCharWithDef.class), e); 2543 } 2544 static void checkSingleMemberCharOvrdDef(SingleMemberCharWithDef a, AnnotatedElement e) { 2545 numTests++; 2546 try { 2547 if (a.value() != '5') fail("SingleMemberCharOvrdDef " + e + " = " + a.value()); 2548 } catch(Throwable t) { 2549 fail("SingleMemberCharOvrdDef " + e + ": " + t); 2550 } 2551 } 2552 2553 static void checkSingleMemberFloatOvrdDef(AnnotatedElement e) { 2554 checkSingleMemberFloatOvrdDef(e.getAnnotation(SingleMemberFloatWithDef.class), e); 2555 } 2556 static void checkSingleMemberFloatOvrdDef(SingleMemberFloatWithDef a, AnnotatedElement e) { 2557 numTests++; 2558 try { 2559 if (a.value() != 6.0f) fail("SingleMemberFloatOvrdDef " + e + " = " + a.value()); 2560 } catch(Throwable t) { 2561 fail("SingleMemberFloatOvrdDef " + e + ": " + t); 2562 } 2563 } 2564 2565 static void checkSingleMemberDoubleOvrdDef(AnnotatedElement e) { 2566 checkSingleMemberDoubleOvrdDef(e.getAnnotation(SingleMemberDoubleWithDef.class), e); 2567 } 2568 static void checkSingleMemberDoubleOvrdDef(SingleMemberDoubleWithDef a, AnnotatedElement e) { 2569 numTests++; 2570 try { 2571 if (a.value() != 7.0) fail("SingleMemberDoubleOvrdDef " + e + " = " + a.value()); 2572 } catch(Throwable t) { 2573 fail("SingleMemberDoubleOvrdDef " + e + ": " + t); 2574 } 2575 } 2576 2577 static void checkSingleMemberBooleanOvrdDef(AnnotatedElement e) { 2578 checkSingleMemberBooleanOvrdDef(e.getAnnotation(SingleMemberBooleanWithDef.class), e); 2579 } 2580 static void checkSingleMemberBooleanOvrdDef(SingleMemberBooleanWithDef a, AnnotatedElement e) { 2581 numTests++; 2582 try { 2583 if (!a.value()) fail("SingleMemberBooleanOvrdDef " + e + " = " + a.value()); 2584 } catch(Throwable t) { 2585 fail("SingleMemberBooleanOvrdDef " + e + ": " + t); 2586 } 2587 } 2588 2589 static void checkSingleMemberStringOvrdDef(AnnotatedElement e) { 2590 checkSingleMemberStringOvrdDef(e.getAnnotation(SingleMemberStringWithDef.class), e); 2591 } 2592 static void checkSingleMemberStringOvrdDef(SingleMemberStringWithDef a, AnnotatedElement e) { 2593 numTests++; 2594 try { 2595 if (!(a.value().equals("custom"))) fail("SingleMemberStringOvrdDef " + e + " = " + a.value()); 2596 } catch(Throwable t) { 2597 fail("SingleMemberStringOvrdDef " + e + ": " + t); 2598 } 2599 } 2600 2601 static void checkSingleMemberClassOvrdDef(AnnotatedElement e) { 2602 checkSingleMemberClassOvrdDef(e.getAnnotation(SingleMemberClassWithDef.class), e); 2603 } 2604 static void checkSingleMemberClassOvrdDef(SingleMemberClassWithDef a, AnnotatedElement e) { 2605 numTests++; 2606 try { 2607 if (a.value() != Map.class) fail("SingleMemberClassOvrdDef " + e + " = " + a.value()); 2608 } catch(Throwable t) { 2609 fail("SingleMemberClassOvrdDef " + e + ": " + t); 2610 } 2611 } 2612 2613 static void checkSingleMemberEnumOvrdDef(AnnotatedElement e) { 2614 checkSingleMemberEnumOvrdDef(e.getAnnotation(SingleMemberEnumWithDef.class), e); 2615 } 2616 static void checkSingleMemberEnumOvrdDef(SingleMemberEnumWithDef a, AnnotatedElement e) { 2617 numTests++; 2618 try { 2619 if (a.value() != Stooge.MOE) fail("SingleMemberEnumOvrdDef " + e + " = " + a.value()); 2620 } catch(Throwable t) { 2621 fail("SingleMemberEnumOvrdDef " + e + ": " + t); 2622 } 2623 } 2624 2625 // Single-member with default (Accept) 2626 2627 static void checkSingleMemberByteAcceptDef(AnnotatedElement e) { 2628 checkSingleMemberByteAcceptDef(e.getAnnotation(SingleMemberByteWithDef.class), e); 2629 } 2630 static void checkSingleMemberByteAcceptDef(SingleMemberByteWithDef a, AnnotatedElement e) { 2631 numTests++; 2632 try { 2633 if (a.value() != 11) fail("SingleMemberByteAcceptDef " + e + " = " + a.value()); 2634 } catch(Throwable t) { 2635 fail("SingleMemberByteAcceptDef " + e + ": " + t); 2636 } 2637 } 2638 2639 static void checkSingleMemberShortAcceptDef(AnnotatedElement e) { 2640 checkSingleMemberShortAcceptDef(e.getAnnotation(SingleMemberShortWithDef.class), e); 2641 } 2642 static void checkSingleMemberShortAcceptDef(SingleMemberShortWithDef a, AnnotatedElement e) { 2643 numTests++; 2644 try { 2645 if (a.value() != 12) fail("SingleMemberShortAcceptDef " + e + " = " + a.value()); 2646 } catch(Throwable t) { 2647 fail("SingleMemberShortAcceptDef " + e + ": " + t); 2648 } 2649 } 2650 2651 static void checkSingleMemberIntAcceptDef(AnnotatedElement e) { 2652 checkSingleMemberIntAcceptDef(e.getAnnotation(SingleMemberIntWithDef.class), e); 2653 } 2654 static void checkSingleMemberIntAcceptDef(SingleMemberIntWithDef a, AnnotatedElement e) { 2655 numTests++; 2656 try { 2657 if (a.value() != 13) fail("SingleMemberIntAcceptDef " + e + " = " + a.value()); 2658 } catch(Throwable t) { 2659 fail("SingleMemberIntAcceptDef " + e + ": " + t); 2660 } 2661 } 2662 2663 static void checkSingleMemberLongAcceptDef(AnnotatedElement e) { 2664 checkSingleMemberLongAcceptDef(e.getAnnotation(SingleMemberLongWithDef.class), e); 2665 } 2666 static void checkSingleMemberLongAcceptDef(SingleMemberLongWithDef a, AnnotatedElement e) { 2667 numTests++; 2668 try { 2669 if (a.value() != 14L) fail("SingleMemberLongAcceptDef " + e + " = " + a.value()); 2670 } catch(Throwable t) { 2671 fail("SingleMemberLongAcceptDef " + e + ": " + t); 2672 } 2673 } 2674 2675 static void checkSingleMemberCharAcceptDef(AnnotatedElement e) { 2676 checkSingleMemberCharAcceptDef(e.getAnnotation(SingleMemberCharWithDef.class), e); 2677 } 2678 static void checkSingleMemberCharAcceptDef(SingleMemberCharWithDef a, AnnotatedElement e) { 2679 numTests++; 2680 try { 2681 if (a.value() != 'V') fail("SingleMemberCharAcceptDef " + e + " = " + a.value()); 2682 } catch(Throwable t) { 2683 fail("SingleMemberCharAcceptDef " + e + ": " + t); 2684 } 2685 } 2686 2687 static void checkSingleMemberFloatAcceptDef(AnnotatedElement e) { 2688 checkSingleMemberFloatAcceptDef(e.getAnnotation(SingleMemberFloatWithDef.class), e); 2689 } 2690 static void checkSingleMemberFloatAcceptDef(SingleMemberFloatWithDef a, AnnotatedElement e) { 2691 numTests++; 2692 try { 2693 if (a.value() != 16.0f) fail("SingleMemberFloatAcceptDef " + e + " = " + a.value()); 2694 } catch(Throwable t) { 2695 fail("SingleMemberFloatAcceptDef " + e + ": " + t); 2696 } 2697 } 2698 2699 static void checkSingleMemberDoubleAcceptDef(AnnotatedElement e) { 2700 checkSingleMemberDoubleAcceptDef(e.getAnnotation(SingleMemberDoubleWithDef.class), e); 2701 } 2702 static void checkSingleMemberDoubleAcceptDef(SingleMemberDoubleWithDef a, AnnotatedElement e) { 2703 numTests++; 2704 try { 2705 if (a.value() != 17.0) fail("SingleMemberDoubleAcceptDef " + e + " = " + a.value()); 2706 } catch(Throwable t) { 2707 fail("SingleMemberDoubleAcceptDef " + e + ": " + t); 2708 } 2709 } 2710 2711 static void checkSingleMemberBooleanAcceptDef(AnnotatedElement e) { 2712 checkSingleMemberBooleanAcceptDef(e.getAnnotation(SingleMemberBooleanWithDef.class), e); 2713 } 2714 static void checkSingleMemberBooleanAcceptDef(SingleMemberBooleanWithDef a, AnnotatedElement e) { 2715 numTests++; 2716 try { 2717 if (a.value()) fail("SingleMemberBooleanAcceptDef " + e + " = " + a.value()); 2718 } catch(Throwable t) { 2719 fail("SingleMemberBooleanAcceptDef " + e + ": " + t); 2720 } 2721 } 2722 2723 static void checkSingleMemberStringAcceptDef(AnnotatedElement e) { 2724 checkSingleMemberStringAcceptDef(e.getAnnotation(SingleMemberStringWithDef.class), e); 2725 } 2726 static void checkSingleMemberStringAcceptDef(SingleMemberStringWithDef a, AnnotatedElement e) { 2727 numTests++; 2728 try { 2729 if (!(a.value().equals("default"))) fail("SingleMemberStringAcceptDef " + e + " = " + a.value()); 2730 } catch(Throwable t) { 2731 fail("SingleMemberStringAcceptDef " + e + ": " + t); 2732 } 2733 } 2734 2735 static void checkSingleMemberClassAcceptDef(AnnotatedElement e) { 2736 checkSingleMemberClassAcceptDef(e.getAnnotation(SingleMemberClassWithDef.class), e); 2737 } 2738 static void checkSingleMemberClassAcceptDef(SingleMemberClassWithDef a, AnnotatedElement e) { 2739 numTests++; 2740 try { 2741 if (a.value() != Class.class) fail("SingleMemberClassAcceptDef " + e + " = " + a.value()); 2742 } catch(Throwable t) { 2743 fail("SingleMemberClassAcceptDef " + e + ": " + t); 2744 } 2745 } 2746 2747 static void checkSingleMemberEnumAcceptDef(AnnotatedElement e) { 2748 checkSingleMemberEnumAcceptDef(e.getAnnotation(SingleMemberEnumWithDef.class), e); 2749 } 2750 static void checkSingleMemberEnumAcceptDef(SingleMemberEnumWithDef a, AnnotatedElement e) { 2751 numTests++; 2752 try { 2753 if (a.value() != Stooge.LARRY) fail("SingleMemberEnumAcceptDef " + e + " = " + a.value()); 2754 } catch(Throwable t) { 2755 fail("SingleMemberEnumAcceptDef " + e + ": " + t); 2756 } 2757 } 2758 2759 // Single member array (empty array) 2760 static void checkSingleMemberByteArrEmpty(AnnotatedElement e) { 2761 checkSingleMemberByteArrEmpty(e.getAnnotation(SingleMemberByteArray.class), e); 2762 } 2763 static void checkSingleMemberByteArrEmpty(SingleMemberByteArray a, AnnotatedElement e) { 2764 numTests++; 2765 try { 2766 if (a.value().length != 0) fail("SingleMemberByteArrEmpty " + e + " = " + a.value()); 2767 } catch(Throwable t) { 2768 fail("SingleMemberByteArrEmpty " + e + ": " + t); 2769 } 2770 } 2771 2772 static void checkSingleMemberShortArrEmpty(AnnotatedElement e) { 2773 checkSingleMemberShortArrEmpty(e.getAnnotation(SingleMemberShortArray.class), e); 2774 } 2775 static void checkSingleMemberShortArrEmpty(SingleMemberShortArray a, AnnotatedElement e) { 2776 numTests++; 2777 try { 2778 if (a.value().length != 0) fail("SingleMemberShortArrEmpty " + e + " = " + a.value()); 2779 } catch(Throwable t) { 2780 fail("SingleMemberShortArrEmpty " + e + ": " + t); 2781 } 2782 } 2783 2784 static void checkSingleMemberIntArrEmpty(AnnotatedElement e) { 2785 checkSingleMemberIntArrEmpty(e.getAnnotation(SingleMemberIntArray.class), e); 2786 } 2787 static void checkSingleMemberIntArrEmpty(SingleMemberIntArray a, AnnotatedElement e) { 2788 numTests++; 2789 try { 2790 if (a.value().length != 0) fail("SingleMemberIntArrEmpty " + e + " = " + a.value()); 2791 } catch(Throwable t) { 2792 fail("SingleMemberIntArrEmpty " + e + ": " + t); 2793 } 2794 } 2795 2796 static void checkSingleMemberLongArrEmpty(AnnotatedElement e) { 2797 checkSingleMemberLongArrEmpty(e.getAnnotation(SingleMemberLongArray.class), e); 2798 } 2799 static void checkSingleMemberLongArrEmpty(SingleMemberLongArray a, AnnotatedElement e) { 2800 numTests++; 2801 try { 2802 if (a.value().length != 0) fail("SingleMemberLongArrEmpty " + e + " = " + a.value()); 2803 } catch(Throwable t) { 2804 fail("SingleMemberLongArrEmpty " + e + ": " + t); 2805 } 2806 } 2807 2808 static void checkSingleMemberCharArrEmpty(AnnotatedElement e) { 2809 checkSingleMemberCharArrEmpty(e.getAnnotation(SingleMemberCharArray.class), e); 2810 } 2811 static void checkSingleMemberCharArrEmpty(SingleMemberCharArray a, AnnotatedElement e) { 2812 numTests++; 2813 try { 2814 if (a.value().length != 0) fail("SingleMemberCharArrEmpty " + e + " = " + a.value()); 2815 } catch(Throwable t) { 2816 fail("SingleMemberCharArrEmpty " + e + ": " + t); 2817 } 2818 } 2819 2820 static void checkSingleMemberFloatArrEmpty(AnnotatedElement e) { 2821 checkSingleMemberFloatArrEmpty(e.getAnnotation(SingleMemberFloatArray.class), e); 2822 } 2823 static void checkSingleMemberFloatArrEmpty(SingleMemberFloatArray a, AnnotatedElement e) { 2824 numTests++; 2825 try { 2826 if (a.value().length != 0) fail("SingleMemberFloatArrEmpty " + e + " = " + a.value()); 2827 } catch(Throwable t) { 2828 fail("SingleMemberFloatArrEmpty " + e + ": " + t); 2829 } 2830 } 2831 2832 static void checkSingleMemberDoubleArrEmpty(AnnotatedElement e) { 2833 checkSingleMemberDoubleArrEmpty(e.getAnnotation(SingleMemberDoubleArray.class), e); 2834 } 2835 static void checkSingleMemberDoubleArrEmpty(SingleMemberDoubleArray a, AnnotatedElement e) { 2836 numTests++; 2837 try { 2838 if (a.value().length != 0) fail("SingleMemberDoubleArrEmpty " + e + " = " + a.value()); 2839 } catch(Throwable t) { 2840 fail("SingleMemberDoubleArrEmpty " + e + ": " + t); 2841 } 2842 } 2843 2844 static void checkSingleMemberBooleanArrEmpty(AnnotatedElement e) { 2845 checkSingleMemberBooleanArrEmpty(e.getAnnotation(SingleMemberBooleanArray.class), e); 2846 } 2847 static void checkSingleMemberBooleanArrEmpty(SingleMemberBooleanArray a, AnnotatedElement e) { 2848 numTests++; 2849 try { 2850 if (a.value().length != 0) fail("SingleMemberBooleanArrEmpty " + e + " = " + a.value()); 2851 } catch(Throwable t) { 2852 fail("SingleMemberBooleanArrEmpty " + e + ": " + t); 2853 } 2854 } 2855 2856 static void checkSingleMemberStringArrEmpty(AnnotatedElement e) { 2857 checkSingleMemberStringArrEmpty(e.getAnnotation(SingleMemberStringArray.class), e); 2858 } 2859 static void checkSingleMemberStringArrEmpty(SingleMemberStringArray a, AnnotatedElement e) { 2860 numTests++; 2861 try { 2862 if (a.value().length != 0) fail("SingleMemberStringArrEmpty " + e + " = " + a.value()); 2863 } catch(Throwable t) { 2864 fail("SingleMemberStringArrEmpty " + e + ": " + t); 2865 } 2866 } 2867 2868 static void checkSingleMemberClassArrEmpty(AnnotatedElement e) { 2869 checkSingleMemberClassArrEmpty(e.getAnnotation(SingleMemberClassArray.class), e); 2870 } 2871 static void checkSingleMemberClassArrEmpty(SingleMemberClassArray a, AnnotatedElement e) { 2872 numTests++; 2873 try { 2874 if (a.value().length != 0) fail("SingleMemberClassArrEmpty " + e + " = " + a.value()); 2875 } catch(Throwable t) { 2876 fail("SingleMemberClassArrEmpty " + e + ": " + t); 2877 } 2878 } 2879 2880 static void checkSingleMemberEnumArrEmpty(AnnotatedElement e) { 2881 checkSingleMemberEnumArrEmpty(e.getAnnotation(SingleMemberEnumArray.class), e); 2882 } 2883 static void checkSingleMemberEnumArrEmpty(SingleMemberEnumArray a, AnnotatedElement e) { 2884 numTests++; 2885 try { 2886 if (a.value().length != 0) fail("SingleMemberEnumArrEmpty " + e + " = " + a.value()); 2887 } catch(Throwable t) { 2888 fail("SingleMemberEnumArrEmpty " + e + ": " + t); 2889 } 2890 } 2891 2892 // Single member array (one element array) 2893 static void checkSingleMemberByteArrOne(AnnotatedElement e) { 2894 checkSingleMemberByteArrOne(e.getAnnotation(SingleMemberByteArray.class), e); 2895 } 2896 static void checkSingleMemberByteArrOne(SingleMemberByteArray a, AnnotatedElement e) { 2897 numTests++; 2898 try { 2899 if (a.value().length != 1 || a.value()[0] != (byte)1) 2900 fail("SingleMemberByteArrOne " + e + " = " + a.value()); 2901 } catch(Throwable t) { 2902 fail("SingleMemberByteArrOne " + e + ": " + t); 2903 } 2904 } 2905 2906 static void checkSingleMemberShortArrOne(AnnotatedElement e) { 2907 checkSingleMemberShortArrOne(e.getAnnotation(SingleMemberShortArray.class), e); 2908 } 2909 static void checkSingleMemberShortArrOne(SingleMemberShortArray a, AnnotatedElement e) { 2910 numTests++; 2911 try { 2912 if (a.value().length != 1 || a.value()[0] != (short)2) 2913 fail("SingleMemberShortArrOne " + e + " = " + a.value()); 2914 } catch(Throwable t) { 2915 fail("SingleMemberShortArrOne " + e + ": " + t); 2916 } 2917 } 2918 2919 static void checkSingleMemberIntArrOne(AnnotatedElement e) { 2920 checkSingleMemberIntArrOne(e.getAnnotation(SingleMemberIntArray.class), e); 2921 } 2922 static void checkSingleMemberIntArrOne(SingleMemberIntArray a, AnnotatedElement e) { 2923 numTests++; 2924 try { 2925 if (a.value().length != 1 || a.value()[0] != 3) 2926 fail("SingleMemberIntArrOne " + e + " = " + a.value()); 2927 } catch(Throwable t) { 2928 fail("SingleMemberIntArrOne " + e + ": " + t); 2929 } 2930 } 2931 2932 static void checkSingleMemberLongArrOne(AnnotatedElement e) { 2933 checkSingleMemberLongArrOne(e.getAnnotation(SingleMemberLongArray.class), e); 2934 } 2935 static void checkSingleMemberLongArrOne(SingleMemberLongArray a, AnnotatedElement e) { 2936 numTests++; 2937 try { 2938 if (a.value().length != 1 || a.value()[0] != 4L) 2939 fail("SingleMemberLongArrOne " + e + " = " + a.value()); 2940 } catch(Throwable t) { 2941 fail("SingleMemberLongArrOne " + e + ": " + t); 2942 } 2943 } 2944 2945 static void checkSingleMemberCharArrOne(AnnotatedElement e) { 2946 checkSingleMemberCharArrOne(e.getAnnotation(SingleMemberCharArray.class), e); 2947 } 2948 static void checkSingleMemberCharArrOne(SingleMemberCharArray a, AnnotatedElement e) { 2949 numTests++; 2950 try { 2951 if (a.value().length != 1 || a.value()[0] != '5') 2952 fail("SingleMemberCharArrOne " + e + " = " + a.value()); 2953 } catch(Throwable t) { 2954 fail("SingleMemberCharArrOne " + e + ": " + t); 2955 } 2956 } 2957 2958 static void checkSingleMemberFloatArrOne(AnnotatedElement e) { 2959 checkSingleMemberFloatArrOne(e.getAnnotation(SingleMemberFloatArray.class), e); 2960 } 2961 static void checkSingleMemberFloatArrOne(SingleMemberFloatArray a, AnnotatedElement e) { 2962 numTests++; 2963 try { 2964 if (a.value().length != 1 || a.value()[0] != 6.0f) 2965 fail("SingleMemberFloatArrOne " + e + " = " + a.value()); 2966 } catch(Throwable t) { 2967 fail("SingleMemberFloatArrOne " + e + ": " + t); 2968 } 2969 } 2970 2971 static void checkSingleMemberDoubleArrOne(AnnotatedElement e) { 2972 checkSingleMemberDoubleArrOne(e.getAnnotation(SingleMemberDoubleArray.class), e); 2973 } 2974 static void checkSingleMemberDoubleArrOne(SingleMemberDoubleArray a, AnnotatedElement e) { 2975 numTests++; 2976 try { 2977 if (a.value().length != 1 || a.value()[0] != 7.0) 2978 fail("SingleMemberDoubleArrOne " + e + " = " + a.value()); 2979 } catch(Throwable t) { 2980 fail("SingleMemberDoubleArrOne " + e + ": " + t); 2981 } 2982 } 2983 2984 static void checkSingleMemberBooleanArrOne(AnnotatedElement e) { 2985 checkSingleMemberBooleanArrOne(e.getAnnotation(SingleMemberBooleanArray.class), e); 2986 } 2987 static void checkSingleMemberBooleanArrOne(SingleMemberBooleanArray a, AnnotatedElement e) { 2988 numTests++; 2989 try { 2990 if (a.value().length != 1 || !a.value()[0]) 2991 fail("SingleMemberBooleanArrOne " + e + " = " + a.value()); 2992 } catch(Throwable t) { 2993 fail("SingleMemberBooleanArrOne " + e + ": " + t); 2994 } 2995 } 2996 2997 static void checkSingleMemberStringArrOne(AnnotatedElement e) { 2998 checkSingleMemberStringArrOne(e.getAnnotation(SingleMemberStringArray.class), e); 2999 } 3000 static void checkSingleMemberStringArrOne(SingleMemberStringArray a, AnnotatedElement e) { 3001 numTests++; 3002 try { 3003 if (a.value().length != 1 || !(a.value()[0].equals("custom"))) 3004 fail("SingleMemberStringArrOne " + e + " = " + a.value()); 3005 } catch(Throwable t) { 3006 fail("SingleMemberStringArrOne " + e + ": " + t); 3007 } 3008 } 3009 3010 static void checkSingleMemberClassArrOne(AnnotatedElement e) { 3011 checkSingleMemberClassArrOne(e.getAnnotation(SingleMemberClassArray.class), e); 3012 } 3013 static void checkSingleMemberClassArrOne(SingleMemberClassArray a, AnnotatedElement e) { 3014 numTests++; 3015 try { 3016 if (a.value().length != 1 || a.value()[0] != Map.class) 3017 fail("SingleMemberClassArrOne " + e + " = " + a.value()); 3018 } catch(Throwable t) { 3019 fail("SingleMemberClassArrOne " + e + ": " + t); 3020 } 3021 } 3022 3023 static void checkSingleMemberEnumArrOne(AnnotatedElement e) { 3024 checkSingleMemberEnumArrOne(e.getAnnotation(SingleMemberEnumArray.class), e); 3025 } 3026 static void checkSingleMemberEnumArrOne(SingleMemberEnumArray a, AnnotatedElement e) { 3027 numTests++; 3028 try { 3029 if (a.value().length != 1 || a.value()[0] != Stooge.MOE) 3030 fail("SingleMemberEnumArrOne " + e + " = " + a.value()); 3031 } catch(Throwable t) { 3032 fail("SingleMemberEnumArrOne " + e + ": " + t); 3033 } 3034 } 3035 3036 // Single member array (two element array) 3037 static void checkSingleMemberByteArrTwo(AnnotatedElement e) { 3038 checkSingleMemberByteArrTwo(e.getAnnotation(SingleMemberByteArray.class), e); 3039 } 3040 static void checkSingleMemberByteArrTwo(SingleMemberByteArray a, AnnotatedElement e) { 3041 numTests++; 3042 try { 3043 if (a.value().length != 2 || a.value()[0] != (byte)1 || a.value()[1] != (byte)2) 3044 fail("SingleMemberByteArrTwo " + e + " = " + a.value()); 3045 } catch(Throwable t) { 3046 fail("SingleMemberByteArrTwo " + e + ": " + t); 3047 } 3048 } 3049 3050 static void checkSingleMemberShortArrTwo(AnnotatedElement e) { 3051 checkSingleMemberShortArrTwo(e.getAnnotation(SingleMemberShortArray.class), e); 3052 } 3053 static void checkSingleMemberShortArrTwo(SingleMemberShortArray a, AnnotatedElement e) { 3054 numTests++; 3055 try { 3056 if (a.value().length != 2 || a.value()[0] != (short)2 || a.value()[1] != (short)3) 3057 fail("SingleMemberShortArrTwo " + e + " = " + a.value()); 3058 } catch(Throwable t) { 3059 fail("SingleMemberShortArrTwo " + e + ": " + t); 3060 } 3061 } 3062 3063 static void checkSingleMemberIntArrTwo(AnnotatedElement e) { 3064 checkSingleMemberIntArrTwo(e.getAnnotation(SingleMemberIntArray.class), e); 3065 } 3066 static void checkSingleMemberIntArrTwo(SingleMemberIntArray a, AnnotatedElement e) { 3067 numTests++; 3068 try { 3069 if (a.value().length != 2 || a.value()[0] != 3 || a.value()[1] != 4) 3070 fail("SingleMemberIntArrTwo " + e + " = " + a.value()); 3071 } catch(Throwable t) { 3072 fail("SingleMemberIntArrTwo " + e + ": " + t); 3073 } 3074 } 3075 3076 static void checkSingleMemberLongArrTwo(AnnotatedElement e) { 3077 checkSingleMemberLongArrTwo(e.getAnnotation(SingleMemberLongArray.class), e); 3078 } 3079 static void checkSingleMemberLongArrTwo(SingleMemberLongArray a, AnnotatedElement e) { 3080 numTests++; 3081 try { 3082 if (a.value().length != 2 || a.value()[0] != 4L || a.value()[1] != 5L) 3083 fail("SingleMemberLongArrTwo " + e + " = " + a.value()); 3084 } catch(Throwable t) { 3085 fail("SingleMemberLongArrTwo " + e + ": " + t); 3086 } 3087 } 3088 3089 static void checkSingleMemberCharArrTwo(AnnotatedElement e) { 3090 checkSingleMemberCharArrTwo(e.getAnnotation(SingleMemberCharArray.class), e); 3091 } 3092 static void checkSingleMemberCharArrTwo(SingleMemberCharArray a, AnnotatedElement e) { 3093 numTests++; 3094 try { 3095 if (a.value().length != 2 || a.value()[0] != '5' || a.value()[1] != '6') 3096 fail("SingleMemberCharArrTwo " + e + " = " + a.value()); 3097 } catch(Throwable t) { 3098 fail("SingleMemberCharArrTwo " + e + ": " + t); 3099 } 3100 } 3101 3102 static void checkSingleMemberFloatArrTwo(AnnotatedElement e) { 3103 checkSingleMemberFloatArrTwo(e.getAnnotation(SingleMemberFloatArray.class), e); 3104 } 3105 static void checkSingleMemberFloatArrTwo(SingleMemberFloatArray a, AnnotatedElement e) { 3106 numTests++; 3107 try { 3108 if (a.value().length != 2 || a.value()[0] != 6.0f || a.value()[1] != 7.0f) 3109 fail("SingleMemberFloatArrTwo " + e + " = " + a.value()); 3110 } catch(Throwable t) { 3111 fail("SingleMemberFloatArrTwo " + e + ": " + t); 3112 } 3113 } 3114 3115 static void checkSingleMemberDoubleArrTwo(AnnotatedElement e) { 3116 checkSingleMemberDoubleArrTwo(e.getAnnotation(SingleMemberDoubleArray.class), e); 3117 } 3118 static void checkSingleMemberDoubleArrTwo(SingleMemberDoubleArray a, AnnotatedElement e) { 3119 numTests++; 3120 try { 3121 if (a.value().length != 2 || a.value()[0] != 7.0 || a.value()[1] != 8.0) 3122 fail("SingleMemberDoubleArrTwo " + e + " = " + a.value()); 3123 } catch(Throwable t) { 3124 fail("SingleMemberDoubleArrTwo " + e + ": " + t); 3125 } 3126 } 3127 3128 static void checkSingleMemberBooleanArrTwo(AnnotatedElement e) { 3129 checkSingleMemberBooleanArrTwo(e.getAnnotation(SingleMemberBooleanArray.class), e); 3130 } 3131 static void checkSingleMemberBooleanArrTwo(SingleMemberBooleanArray a, AnnotatedElement e) { 3132 numTests++; 3133 try { 3134 if (a.value().length != 2 || !a.value()[0] || a.value()[1]) 3135 fail("SingleMemberBooleanArrTwo " + e + " = " + a.value()); 3136 } catch(Throwable t) { 3137 fail("SingleMemberBooleanArrTwo " + e + ": " + t); 3138 } 3139 } 3140 3141 static void checkSingleMemberStringArrTwo(AnnotatedElement e) { 3142 checkSingleMemberStringArrTwo(e.getAnnotation(SingleMemberStringArray.class), e); 3143 } 3144 static void checkSingleMemberStringArrTwo(SingleMemberStringArray a, AnnotatedElement e) { 3145 numTests++; 3146 try { 3147 if (a.value().length != 2 || !(a.value()[0].equals("custom")) || !(a.value()[1].equals("paint"))) 3148 fail("SingleMemberStringArrTwo " + e + " = " + a.value()); 3149 } catch(Throwable t) { 3150 fail("SingleMemberStringArrTwo " + e + ": " + t); 3151 } 3152 } 3153 3154 static void checkSingleMemberClassArrTwo(AnnotatedElement e) { 3155 checkSingleMemberClassArrTwo(e.getAnnotation(SingleMemberClassArray.class), e); 3156 } 3157 static void checkSingleMemberClassArrTwo(SingleMemberClassArray a, AnnotatedElement e) { 3158 numTests++; 3159 try { 3160 if (a.value().length != 2 || a.value()[0] != Map.class || a.value()[1] != Set.class) 3161 fail("SingleMemberClassArrTwo " + e + " = " + a.value()); 3162 } catch(Throwable t) { 3163 fail("SingleMemberClassArrTwo " + e + ": " + t); 3164 } 3165 } 3166 3167 static void checkSingleMemberEnumArrTwo(AnnotatedElement e) { 3168 checkSingleMemberEnumArrTwo(e.getAnnotation(SingleMemberEnumArray.class), e); 3169 } 3170 static void checkSingleMemberEnumArrTwo(SingleMemberEnumArray a, AnnotatedElement e) { 3171 numTests++; 3172 try { 3173 if (a.value().length != 2 || a.value()[0] != Stooge.MOE || a.value()[1] != Stooge.CURLY) 3174 fail("SingleMemberEnumArrTwo " + e + " = " + a.value()); 3175 } catch(Throwable t) { 3176 fail("SingleMemberEnumArrTwo " + e + ": " + t); 3177 } 3178 } 3179 3180 // Single member array with default (override) 3181 static void checkSingleMemberByteArrOvrdDef(AnnotatedElement e) { 3182 checkSingleMemberByteArrOvrdDef(e.getAnnotation(SingleMemberByteArrayDef.class), e); 3183 } 3184 static void checkSingleMemberByteArrOvrdDef(SingleMemberByteArrayDef a, AnnotatedElement e) { 3185 numTests++; 3186 try { 3187 if (a.value().length != 1 || a.value()[0] != (byte)1) 3188 fail("SingleMemberByteArrOvrdDef " + e + " = " + a.value()); 3189 } catch(Throwable t) { 3190 fail("SingleMemberByteArrOvrdDef " + e + ": " + t); 3191 } 3192 } 3193 3194 static void checkSingleMemberShortArrOvrdDef(AnnotatedElement e) { 3195 checkSingleMemberShortArrOvrdDef(e.getAnnotation(SingleMemberShortArrayDef.class), e); 3196 } 3197 static void checkSingleMemberShortArrOvrdDef(SingleMemberShortArrayDef a, AnnotatedElement e) { 3198 numTests++; 3199 try { 3200 if (a.value().length != 1 || a.value()[0] != (short)2) 3201 fail("SingleMemberShortArrOvrdDef " + e + " = " + a.value()); 3202 } catch(Throwable t) { 3203 fail("SingleMemberShortArrOvrdDef " + e + ": " + t); 3204 } 3205 } 3206 3207 static void checkSingleMemberIntArrOvrdDef(AnnotatedElement e) { 3208 checkSingleMemberIntArrOvrdDef(e.getAnnotation(SingleMemberIntArrayDef.class), e); 3209 } 3210 static void checkSingleMemberIntArrOvrdDef(SingleMemberIntArrayDef a, AnnotatedElement e) { 3211 numTests++; 3212 try { 3213 if (a.value().length != 1 || a.value()[0] != 3) 3214 fail("SingleMemberIntArrOvrdDef " + e + " = " + a.value()); 3215 } catch(Throwable t) { 3216 fail("SingleMemberIntArrOvrdDef " + e + ": " + t); 3217 } 3218 } 3219 3220 static void checkSingleMemberLongArrOvrdDef(AnnotatedElement e) { 3221 checkSingleMemberLongArrOvrdDef(e.getAnnotation(SingleMemberLongArrayDef.class), e); 3222 } 3223 static void checkSingleMemberLongArrOvrdDef(SingleMemberLongArrayDef a, AnnotatedElement e) { 3224 numTests++; 3225 try { 3226 if (a.value().length != 1 || a.value()[0] != 4L) 3227 fail("SingleMemberLongArrOvrdDef " + e + " = " + a.value()); 3228 } catch(Throwable t) { 3229 fail("SingleMemberLongArrOvrdDef " + e + ": " + t); 3230 } 3231 } 3232 3233 static void checkSingleMemberCharArrOvrdDef(AnnotatedElement e) { 3234 checkSingleMemberCharArrOvrdDef(e.getAnnotation(SingleMemberCharArrayDef.class), e); 3235 } 3236 static void checkSingleMemberCharArrOvrdDef(SingleMemberCharArrayDef a, AnnotatedElement e) { 3237 numTests++; 3238 try { 3239 if (a.value().length != 1 || a.value()[0] != '5') 3240 fail("SingleMemberCharArrOvrdDef " + e + " = " + a.value()); 3241 } catch(Throwable t) { 3242 fail("SingleMemberCharArrOvrdDef " + e + ": " + t); 3243 } 3244 } 3245 3246 static void checkSingleMemberFloatArrOvrdDef(AnnotatedElement e) { 3247 checkSingleMemberFloatArrOvrdDef(e.getAnnotation(SingleMemberFloatArrayDef.class), e); 3248 } 3249 static void checkSingleMemberFloatArrOvrdDef(SingleMemberFloatArrayDef a, AnnotatedElement e) { 3250 numTests++; 3251 try { 3252 if (a.value().length != 1 || a.value()[0] != 6.0f) 3253 fail("SingleMemberFloatArrOvrdDef " + e + " = " + a.value()); 3254 } catch(Throwable t) { 3255 fail("SingleMemberFloatArrOvrdDef " + e + ": " + t); 3256 } 3257 } 3258 3259 static void checkSingleMemberDoubleArrOvrdDef(AnnotatedElement e) { 3260 checkSingleMemberDoubleArrOvrdDef(e.getAnnotation(SingleMemberDoubleArrayDef.class), e); 3261 } 3262 static void checkSingleMemberDoubleArrOvrdDef(SingleMemberDoubleArrayDef a, AnnotatedElement e) { 3263 numTests++; 3264 try { 3265 if (a.value().length != 1 || a.value()[0] != 7.0) 3266 fail("SingleMemberDoubleArrOvrdDef " + e + " = " + a.value()); 3267 } catch(Throwable t) { 3268 fail("SingleMemberDoubleArrOvrdDef " + e + ": " + t); 3269 } 3270 } 3271 3272 static void checkSingleMemberBooleanArrOvrdDef(AnnotatedElement e) { 3273 checkSingleMemberBooleanArrOvrdDef(e.getAnnotation(SingleMemberBooleanArrayDef.class), e); 3274 } 3275 static void checkSingleMemberBooleanArrOvrdDef(SingleMemberBooleanArrayDef a, AnnotatedElement e) { 3276 numTests++; 3277 try { 3278 if (a.value().length != 1 || !a.value()[0]) 3279 fail("SingleMemberBooleanArrOvrdDef " + e + " = " + a.value()); 3280 } catch(Throwable t) { 3281 fail("SingleMemberBooleanArrOvrdDef " + e + ": " + t); 3282 } 3283 } 3284 3285 static void checkSingleMemberStringArrOvrdDef(AnnotatedElement e) { 3286 checkSingleMemberStringArrOvrdDef(e.getAnnotation(SingleMemberStringArrayDef.class), e); 3287 } 3288 static void checkSingleMemberStringArrOvrdDef(SingleMemberStringArrayDef a, AnnotatedElement e) { 3289 numTests++; 3290 try { 3291 if (a.value().length != 1 || !(a.value()[0].equals("custom"))) 3292 fail("SingleMemberStringArrOvrdDef " + e + " = " + a.value()); 3293 } catch(Throwable t) { 3294 fail("SingleMemberStringArrOvrdDef " + e + ": " + t); 3295 } 3296 } 3297 3298 static void checkSingleMemberClassArrOvrdDef(AnnotatedElement e) { 3299 checkSingleMemberClassArrOvrdDef(e.getAnnotation(SingleMemberClassArrayDef.class), e); 3300 } 3301 static void checkSingleMemberClassArrOvrdDef(SingleMemberClassArrayDef a, AnnotatedElement e) { 3302 numTests++; 3303 try { 3304 if (a.value().length != 1 || a.value()[0] != Map.class) 3305 fail("SingleMemberClassArrOvrdDef " + e + " = " + a.value()); 3306 } catch(Throwable t) { 3307 fail("SingleMemberClassArrOvrdDef " + e + ": " + t); 3308 } 3309 } 3310 3311 static void checkSingleMemberEnumArrOvrdDef(AnnotatedElement e) { 3312 checkSingleMemberEnumArrOvrdDef(e.getAnnotation(SingleMemberEnumArrayDef.class), e); 3313 } 3314 static void checkSingleMemberEnumArrOvrdDef(SingleMemberEnumArrayDef a, AnnotatedElement e) { 3315 numTests++; 3316 try { 3317 if (a.value().length != 1 || a.value()[0] != Stooge.MOE) 3318 fail("SingleMemberEnumArrOvrdDef " + e + " = " + a.value()); 3319 } catch(Throwable t) { 3320 fail("SingleMemberEnumArrOvrdDef " + e + ": " + t); 3321 } 3322 } 3323 3324 // Single member array with default (accept) 3325 static void checkSingleMemberByteArrAcceptDef(AnnotatedElement e) { 3326 checkSingleMemberByteArrAcceptDef(e.getAnnotation(SingleMemberByteArrayDef.class), e); 3327 } 3328 static void checkSingleMemberByteArrAcceptDef(SingleMemberByteArrayDef a, AnnotatedElement e) { 3329 numTests++; 3330 try { 3331 if (a.value().length != 1 || a.value()[0] != (byte)11) 3332 fail("SingleMemberByteArrAcceptDef " + e + " = " + a.value()); 3333 } catch(Throwable t) { 3334 fail("SingleMemberByteArrAcceptDef " + e + ": " + t); 3335 } 3336 } 3337 3338 static void checkSingleMemberShortArrAcceptDef(AnnotatedElement e) { 3339 checkSingleMemberShortArrAcceptDef(e.getAnnotation(SingleMemberShortArrayDef.class), e); 3340 } 3341 static void checkSingleMemberShortArrAcceptDef(SingleMemberShortArrayDef a, AnnotatedElement e) { 3342 numTests++; 3343 try { 3344 if (a.value().length != 1 || a.value()[0] != (short)12) 3345 fail("SingleMemberShortArrAcceptDef " + e + " = " + a.value()); 3346 } catch(Throwable t) { 3347 fail("SingleMemberShortArrAcceptDef " + e + ": " + t); 3348 } 3349 } 3350 3351 static void checkSingleMemberIntArrAcceptDef(AnnotatedElement e) { 3352 checkSingleMemberIntArrAcceptDef(e.getAnnotation(SingleMemberIntArrayDef.class), e); 3353 } 3354 static void checkSingleMemberIntArrAcceptDef(SingleMemberIntArrayDef a, AnnotatedElement e) { 3355 numTests++; 3356 try { 3357 if (a.value().length != 1 || a.value()[0] != 13) 3358 fail("SingleMemberIntArrAcceptDef " + e + " = " + a.value()); 3359 } catch(Throwable t) { 3360 fail("SingleMemberIntArrAcceptDef " + e + ": " + t); 3361 } 3362 } 3363 3364 static void checkSingleMemberLongArrAcceptDef(AnnotatedElement e) { 3365 checkSingleMemberLongArrAcceptDef(e.getAnnotation(SingleMemberLongArrayDef.class), e); 3366 } 3367 static void checkSingleMemberLongArrAcceptDef(SingleMemberLongArrayDef a, AnnotatedElement e) { 3368 numTests++; 3369 try { 3370 if (a.value().length != 1 || a.value()[0] != 14L) 3371 fail("SingleMemberLongArrAcceptDef " + e + " = " + a.value()); 3372 } catch(Throwable t) { 3373 fail("SingleMemberLongArrAcceptDef " + e + ": " + t); 3374 } 3375 } 3376 3377 static void checkSingleMemberCharArrAcceptDef(AnnotatedElement e) { 3378 checkSingleMemberCharArrAcceptDef(e.getAnnotation(SingleMemberCharArrayDef.class), e); 3379 } 3380 static void checkSingleMemberCharArrAcceptDef(SingleMemberCharArrayDef a, AnnotatedElement e) { 3381 numTests++; 3382 try { 3383 if (a.value().length != 1 || a.value()[0] != 'V') 3384 fail("SingleMemberCharArrAcceptDef " + e + " = " + a.value()); 3385 } catch(Throwable t) { 3386 fail("SingleMemberCharArrAcceptDef " + e + ": " + t); 3387 } 3388 } 3389 3390 static void checkSingleMemberFloatArrAcceptDef(AnnotatedElement e) { 3391 checkSingleMemberFloatArrAcceptDef(e.getAnnotation(SingleMemberFloatArrayDef.class), e); 3392 } 3393 static void checkSingleMemberFloatArrAcceptDef(SingleMemberFloatArrayDef a, AnnotatedElement e) { 3394 numTests++; 3395 try { 3396 if (a.value().length != 1 || a.value()[0] != 16.0f) 3397 fail("SingleMemberFloatArrAcceptDef " + e + " = " + a.value()); 3398 } catch(Throwable t) { 3399 fail("SingleMemberFloatArrAcceptDef " + e + ": " + t); 3400 } 3401 } 3402 3403 static void checkSingleMemberDoubleArrAcceptDef(AnnotatedElement e) { 3404 checkSingleMemberDoubleArrAcceptDef(e.getAnnotation(SingleMemberDoubleArrayDef.class), e); 3405 } 3406 static void checkSingleMemberDoubleArrAcceptDef(SingleMemberDoubleArrayDef a, AnnotatedElement e) { 3407 numTests++; 3408 try { 3409 if (a.value().length != 1 || a.value()[0] != 17.0) 3410 fail("SingleMemberDoubleArrAcceptDef " + e + " = " + a.value()); 3411 } catch(Throwable t) { 3412 fail("SingleMemberDoubleArrAcceptDef " + e + ": " + t); 3413 } 3414 } 3415 3416 static void checkSingleMemberBooleanArrAcceptDef(AnnotatedElement e) { 3417 checkSingleMemberBooleanArrAcceptDef(e.getAnnotation(SingleMemberBooleanArrayDef.class), e); 3418 } 3419 static void checkSingleMemberBooleanArrAcceptDef(SingleMemberBooleanArrayDef a, AnnotatedElement e) { 3420 numTests++; 3421 try { 3422 if (a.value().length != 1 || a.value()[0]) 3423 fail("SingleMemberBooleanArrAcceptDef " + e + " = " + a.value()); 3424 } catch(Throwable t) { 3425 fail("SingleMemberBooleanArrAcceptDef " + e + ": " + t); 3426 } 3427 } 3428 3429 static void checkSingleMemberStringArrAcceptDef(AnnotatedElement e) { 3430 checkSingleMemberStringArrAcceptDef(e.getAnnotation(SingleMemberStringArrayDef.class), e); 3431 } 3432 static void checkSingleMemberStringArrAcceptDef(SingleMemberStringArrayDef a, AnnotatedElement e) { 3433 numTests++; 3434 try { 3435 if (a.value().length != 1 || !(a.value()[0].equals("default"))) 3436 fail("SingleMemberStringArrAcceptDef " + e + " = " + a.value()); 3437 } catch(Throwable t) { 3438 fail("SingleMemberStringArrAcceptDef " + e + ": " + t); 3439 } 3440 } 3441 3442 static void checkSingleMemberClassArrAcceptDef(AnnotatedElement e) { 3443 checkSingleMemberClassArrAcceptDef(e.getAnnotation(SingleMemberClassArrayDef.class), e); 3444 } 3445 static void checkSingleMemberClassArrAcceptDef(SingleMemberClassArrayDef a, AnnotatedElement e) { 3446 numTests++; 3447 try { 3448 if (a.value().length != 1 || a.value()[0] != Class.class) 3449 fail("SingleMemberClassArrAcceptDef " + e + " = " + a.value()); 3450 } catch(Throwable t) { 3451 fail("SingleMemberClassArrAcceptDef " + e + ": " + t); 3452 } 3453 } 3454 3455 static void checkSingleMemberEnumArrAcceptDef(AnnotatedElement e) { 3456 checkSingleMemberEnumArrAcceptDef(e.getAnnotation(SingleMemberEnumArrayDef.class), e); 3457 } 3458 static void checkSingleMemberEnumArrAcceptDef(SingleMemberEnumArrayDef a, AnnotatedElement e) { 3459 numTests++; 3460 try { 3461 if (a.value().length != 1 || a.value()[0] != Stooge.LARRY) 3462 fail("SingleMemberEnumArrAcceptDef " + e + " = " + a.value()); 3463 } catch(Throwable t) { 3464 fail("SingleMemberEnumArrAcceptDef " + e + ": " + t); 3465 } 3466 } 3467 3468 // Verfification methods for equals/hashCode/serialization 3469 3470 static <T extends Annotation> void checkEquals(AnnotatedElement e1, AnnotatedElement e2, Class<T> annoType) { 3471 numTests++; 3472 T a1 = e1.getAnnotation(annoType); 3473 T a2 = e2.getAnnotation(annoType); 3474 try { 3475 if (!a1.equals(a2)) 3476 fail(a1 + " != " + a2); 3477 if (a1.hashCode() != a2.hashCode()) 3478 fail(a1 + ".hashCode() [" + a1.hashCode() + "] != " + a2 + " .hashCode()["+ a2.hashCode()+"]"); 3479 if (!(a1.toString().equals(a2.toString()))) 3480 fail(a1 + ".toString() != " + a2 + ".toString()"); 3481 } catch(Throwable t) { 3482 fail(a1 + " == " + a2 + ": " + t); 3483 } 3484 } 3485 3486 static <T extends Annotation> void checkUnequals(AnnotatedElement e1, AnnotatedElement e2, Class<T> annoType) { 3487 numTests++; 3488 T a1 = e1.getAnnotation(annoType); 3489 T a2 = e2.getAnnotation(annoType); 3490 try { 3491 if (a1.equals(a2)) 3492 fail(a1 + " == " + a2); 3493 if (a1.hashCode() == a2.hashCode()) 3494 fail(a1 + ".hashCode() [" + a1.hashCode() + "] == " + a2 + " .hashCode()[" + a2.hashCode() + "]"); 3495 if (a1.toString().equals(a2.toString())) 3496 fail(a1 + ".toString() == " + a2 + ".toString()"); 3497 } catch(Throwable t) { 3498 fail(a1 + " != " + a2 + ": " + t); 3499 } 3500 } 3501 3502 // Verfification method for serialization/deserialization 3503 3504 static <T extends Annotation> void checkSerialization(AnnotatedElement e, Class<T> annoType) { 3505 numTests++; 3506 T a1 = e.getAnnotation(annoType); 3507 Object a2 = deepCopy(a1); 3508 try { 3509 if (!a1.equals(a2)) 3510 fail("Serialization: " + a1 + " != " + a2); 3511 if (a1.hashCode() != a2.hashCode()) 3512 fail("Serialization: " + a1 + ".hashCode() [" + a1.hashCode() + "] != " + a2 + " .hashCode()["+a2.hashCode()+"]"); 3513 if (!(a1.toString().equals(a2.toString()))) 3514 fail("Serialization: " + a1 + ".toString() != " + a2 + ".toString()"); 3515 } catch(Throwable t) { 3516 fail("Serialization: " + a1 + " == " + a2 + ": " + t); 3517 } 3518 } 3519 3520 private static Object deepCopy(Object original) { 3521 try { 3522 ByteArrayOutputStream bos = new ByteArrayOutputStream(); 3523 ObjectOutputStream oos = new ObjectOutputStream(bos); 3524 oos.writeObject(original); 3525 oos.flush(); 3526 ByteArrayInputStream bin = new ByteArrayInputStream( 3527 bos.toByteArray()); 3528 ObjectInputStream ois = new ObjectInputStream(bin); 3529 return ois.readObject(); 3530 } catch(Exception e) { 3531 throw new IllegalArgumentException(e); 3532 } 3533 } 3534 3535 // Verification method for inheritance test 3536 static void checkInheritence(AnnotatedElement e, boolean shouldHaveFoo, boolean shouldHaveBar) { 3537 numTests++; 3538 try { 3539 boolean hasFoo = e.isAnnotationPresent(Foo.class); 3540 boolean hasBar = e.isAnnotationPresent(Bar.class); 3541 if (hasFoo != shouldHaveFoo || hasBar != shouldHaveBar) 3542 fail("Inheritance(1): " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar); 3543 3544 // Now test getAnnotations 3545 hasFoo = hasBar = false; 3546 Annotation[] allAnnotations = e.getAnnotations(); 3547 for (Annotation a : allAnnotations) { 3548 if (a instanceof Foo) 3549 hasFoo = true; 3550 else if (a instanceof Bar) 3551 hasBar = true; 3552 } 3553 if (hasFoo != shouldHaveFoo ||hasBar != shouldHaveBar) 3554 fail("Inheritance(2): " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar); 3555 } catch(Throwable t) { 3556 fail("Inheritance: " + e +": " + t); 3557 } 3558 } 3559 3560 // Verification method for declared annotations test 3561 static void checkDeclaredAnnotations(AnnotatedElement e, boolean shouldHaveFoo, boolean shouldHaveBar) { 3562 numTests++; 3563 try { 3564 boolean hasFoo = false; 3565 boolean hasBar = false; 3566 Annotation[] declaredAnnotations = e.getDeclaredAnnotations(); 3567 for (Annotation a : declaredAnnotations) { 3568 if (a instanceof Foo) 3569 hasFoo = true; 3570 else if (a instanceof Bar) 3571 hasBar = true; 3572 } 3573 if (hasFoo != shouldHaveFoo ||hasBar != shouldHaveBar) 3574 fail("Declared annotations: " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar); 3575 } catch(Throwable t) { 3576 fail("Declared annotations: " + e +": " + t); 3577 } 3578 } 3579 3580 3581 // ANNOTATED METHODS 3582 3583 @ScalarTypes ( 3584 b = 1, 3585 s = 2, 3586 i = 3, 3587 l = 4L, 3588 c = '5', 3589 f = 6.0f, 3590 d = 7.0, 3591 bool = true, 3592 str = "custom", 3593 cls = Map.class, 3594 e = Stooge.MOE, 3595 a = @Point(x = 1, y = 2) 3596 ) 3597 public void scalarTypesMethod() { } 3598 3599 @ScalarTypesWithDefault ( ) 3600 public void scalarTypesAcceptDefaultMethod() { } 3601 3602 @ScalarTypesWithDefault ( 3603 b = 1, 3604 s = 2, 3605 i = 3, 3606 l = 4L, 3607 c = '5', 3608 f = 6.0f, 3609 d = 7.0, 3610 bool = true, 3611 str = "custom", 3612 cls = Map.class, 3613 e = Stooge.MOE 3614 ) 3615 public void scalarTypesOverrideDefaultMethod() { } 3616 3617 @ArrayTypes ( 3618 b = { }, 3619 s = { }, 3620 i = { }, 3621 l = { }, 3622 c = { }, 3623 f = { }, 3624 d = { }, 3625 bool = { }, 3626 str = { }, 3627 cls = { }, 3628 e = { }, 3629 a = { } 3630 ) 3631 public void emptyArrayTypesMethod() { } 3632 3633 @ArrayTypes ( 3634 b = 1, 3635 s = 2, 3636 i = 3, 3637 l = 4L, 3638 c = '5', 3639 f = 6.0f, 3640 d = 7.0, 3641 bool = true, 3642 str = "custom", 3643 cls = Map.class, 3644 e = Stooge.MOE, 3645 a = { @Point(x = 1, y = 2) } 3646 ) 3647 public void singleElementArrayTypesMethod() { } 3648 3649 @ArrayTypes ( 3650 b = { 1, 2 }, 3651 s = { 2, 3 }, 3652 i = { 3, 4 }, 3653 l = { 4L, 5L }, 3654 c = { '5', '6' }, 3655 f = { 6.0f, 7.0f }, 3656 d = { 7.0, 8.0 }, 3657 bool = { true, false }, 3658 str = { "custom", "paint" }, 3659 cls = { Map.class, Set.class }, 3660 e = { Stooge.MOE, Stooge.CURLY }, 3661 a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) } 3662 ) 3663 public void twoElementArrayTypesMethod() { } 3664 3665 @ArrayTypesWithDefault ( 3666 ) 3667 public void arrayTypesAcceptDefaultMethod() { } 3668 3669 @ArrayTypesWithDefault ( 3670 b = 1, 3671 s = 2, 3672 i = 3, 3673 l = 4L, 3674 c = '5', 3675 f = 6.0f, 3676 d = 7.0, 3677 bool = true, 3678 str = "custom", 3679 cls = Map.class, 3680 e = Stooge.MOE, 3681 a = { @Point(x = 1, y = 2) } 3682 ) 3683 public void arrayTypesOverrideDefaultMethod() { } 3684 3685 // Marker 3686 @Marker public void markerMethod() { } 3687 3688 // Single-member (shorthand) 3689 @SingleMemberByte(1) public void SingleMemberByte() {} 3690 @SingleMemberShort(2) public void SingleMemberShort() {} 3691 @SingleMemberInt(3) public void SingleMemberInt() {} 3692 @SingleMemberLong(4L) public void SingleMemberLong() {} 3693 @SingleMemberChar('5') public void SingleMemberChar() {} 3694 @SingleMemberFloat(6.0f) public void SingleMemberFloat() {} 3695 @SingleMemberDouble(7.0) public void SingleMemberDouble() {} 3696 @SingleMemberBoolean(true) public void SingleMemberBoolean() {} 3697 @SingleMemberString("custom") public void SingleMemberString() {} 3698 @SingleMemberClass(Map.class) public void SingleMemberClass() {} 3699 @SingleMemberEnum(Stooge.MOE) public void SingleMemberEnum() {} 3700 3701 // Single-member with default (Override) 3702 @SingleMemberByteWithDef(1) public void SingleMemberByteOvrdDef() {} 3703 @SingleMemberShortWithDef(2) public void SingleMemberShortOvrdDef() {} 3704 @SingleMemberIntWithDef(3) public void SingleMemberIntOvrdDef() {} 3705 @SingleMemberLongWithDef(4L) public void SingleMemberLongOvrdDef() {} 3706 @SingleMemberCharWithDef('5') public void SingleMemberCharOvrdDef() {} 3707 @SingleMemberFloatWithDef(6.0f) public void SingleMemberFloatOvrdDef() {} 3708 @SingleMemberDoubleWithDef(7.0) public void SingleMemberDoubleOvrdDef() {} 3709 @SingleMemberBooleanWithDef(true) public void SingleMemberBooleanOvrdDef() {} 3710 @SingleMemberStringWithDef("custom") public void SingleMemberStringOvrdDef() {} 3711 @SingleMemberClassWithDef(Map.class) public void SingleMemberClassOvrdDef() {} 3712 @SingleMemberEnumWithDef(Stooge.MOE) public void SingleMemberEnumOvrdDef() {} 3713 3714 // Single-member with default (Accept) 3715 @SingleMemberByteWithDef public void SingleMemberByteAcceptDef() {} 3716 @SingleMemberShortWithDef public void SingleMemberShortAcceptDef() {} 3717 @SingleMemberIntWithDef public void SingleMemberIntAcceptDef() {} 3718 @SingleMemberLongWithDef public void SingleMemberLongAcceptDef() {} 3719 @SingleMemberCharWithDef public void SingleMemberCharAcceptDef() {} 3720 @SingleMemberFloatWithDef public void SingleMemberFloatAcceptDef() {} 3721 @SingleMemberDoubleWithDef public void SingleMemberDoubleAcceptDef() {} 3722 @SingleMemberBooleanWithDef public void SingleMemberBooleanAcceptDef() {} 3723 @SingleMemberStringWithDef public void SingleMemberStringAcceptDef() {} 3724 @SingleMemberClassWithDef public void SingleMemberClassAcceptDef() {} 3725 @SingleMemberEnumWithDef public void SingleMemberEnumAcceptDef() {} 3726 3727 // Single member array (empty array) 3728 @SingleMemberByteArray({}) public void SingleMemberByteArrEmpty() {} 3729 @SingleMemberShortArray({}) public void SingleMemberShortArrEmpty() {} 3730 @SingleMemberIntArray({}) public void SingleMemberIntArrEmpty() {} 3731 @SingleMemberLongArray({}) public void SingleMemberLongArrEmpty() {} 3732 @SingleMemberCharArray({}) public void SingleMemberCharArrEmpty() {} 3733 @SingleMemberFloatArray({}) public void SingleMemberFloatArrEmpty() {} 3734 @SingleMemberDoubleArray({}) public void SingleMemberDoubleArrEmpty() {} 3735 @SingleMemberBooleanArray({})public void SingleMemberBooleanArrEmpty() {} 3736 @SingleMemberStringArray({}) public void SingleMemberStringArrEmpty() {} 3737 @SingleMemberClassArray({}) public void SingleMemberClassArrEmpty() {} 3738 @SingleMemberEnumArray({}) public void SingleMemberEnumArrEmpty() {} 3739 3740 // Single member array (one-element shorthand) 3741 @SingleMemberByteArray(1) public void SingleMemberByteArrOne() {} 3742 @SingleMemberShortArray(2) public void SingleMemberShortArrOne() {} 3743 @SingleMemberIntArray(3) public void SingleMemberIntArrOne() {} 3744 @SingleMemberLongArray(4L) public void SingleMemberLongArrOne() {} 3745 @SingleMemberCharArray('5') public void SingleMemberCharArrOne() {} 3746 @SingleMemberFloatArray(6.0f) public void SingleMemberFloatArrOne() {} 3747 @SingleMemberDoubleArray(7.0) public void SingleMemberDoubleArrOne() {} 3748 @SingleMemberBooleanArray(true) public void SingleMemberBooleanArrOne() {} 3749 @SingleMemberStringArray("custom") public void SingleMemberStringArrOne() {} 3750 @SingleMemberClassArray(Map.class) public void SingleMemberClassArrOne() {} 3751 @SingleMemberEnumArray(Stooge.MOE) public void SingleMemberEnumArrOne() {} 3752 3753 // Single member array (two elements) 3754 @SingleMemberByteArray({1, 2}) public void SingleMemberByteArrTwo() {} 3755 @SingleMemberShortArray({2, 3}) public void SingleMemberShortArrTwo() {} 3756 @SingleMemberIntArray({3, 4}) public void SingleMemberIntArrTwo() {} 3757 @SingleMemberLongArray({4L, 5L}) public void SingleMemberLongArrTwo() {} 3758 @SingleMemberCharArray({'5', '6'}) public void SingleMemberCharArrTwo() {} 3759 @SingleMemberFloatArray({6.0f, 7.0f}) public void SingleMemberFloatArrTwo() {} 3760 @SingleMemberDoubleArray({7.0, 8.0}) public void SingleMemberDoubleArrTwo() {} 3761 @SingleMemberBooleanArray({true, false}) public void SingleMemberBooleanArrTwo(){} 3762 @SingleMemberStringArray({"custom", "paint"}) public void SingleMemberStringArrTwo(){} 3763 @SingleMemberClassArray({Map.class, Set.class}) public void SingleMemberClassArrTwo() {} 3764 @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public void SingleMemberEnumArrTwo() {} 3765 3766 // Single member array with default (override) 3767 @SingleMemberByteArrayDef(1) public void SingleMemberByteArrOvrdDef() {} 3768 @SingleMemberShortArrayDef(2) public void SingleMemberShortArrOvrdDef() {} 3769 @SingleMemberIntArrayDef(3) public void SingleMemberIntArrOvrdDef() {} 3770 @SingleMemberLongArrayDef(4L) public void SingleMemberLongArrOvrdDef() {} 3771 @SingleMemberCharArrayDef('5') public void SingleMemberCharArrOvrdDef() {} 3772 @SingleMemberFloatArrayDef(6.0f) public void SingleMemberFloatArrOvrdDef() {} 3773 @SingleMemberDoubleArrayDef(7.0) public void SingleMemberDoubleArrOvrdDef() {} 3774 @SingleMemberBooleanArrayDef(true) public void SingleMemberBooleanArrOvrdDef(){} 3775 @SingleMemberStringArrayDef("custom") public void SingleMemberStringArrOvrdDef() {} 3776 @SingleMemberClassArrayDef(Map.class) public void SingleMemberClassArrOvrdDef() {} 3777 @SingleMemberEnumArrayDef(Stooge.MOE) public void SingleMemberEnumArrOvrdDef() {} 3778 3779 // Single member array with default - accept 3780 @SingleMemberByteArrayDef public void SingleMemberByteArrAcceptDef() {} 3781 @SingleMemberShortArrayDef public void SingleMemberShortArrAcceptDef() {} 3782 @SingleMemberIntArrayDef public void SingleMemberIntArrAcceptDef() {} 3783 @SingleMemberLongArrayDef public void SingleMemberLongArrAcceptDef() {} 3784 @SingleMemberCharArrayDef public void SingleMemberCharArrAcceptDef() {} 3785 @SingleMemberFloatArrayDef public void SingleMemberFloatArrAcceptDef() {} 3786 @SingleMemberDoubleArrayDef public void SingleMemberDoubleArrAcceptDef() {} 3787 @SingleMemberBooleanArrayDef public void SingleMemberBooleanArrAcceptDef() {} 3788 @SingleMemberStringArrayDef public void SingleMemberStringArrAcceptDef() {} 3789 @SingleMemberClassArrayDef public void SingleMemberClassArrAcceptDef() {} 3790 @SingleMemberEnumArrayDef public void SingleMemberEnumArrAcceptDef() {} 3791 3792 // ANNOTATED FIELDS 3793 @ScalarTypes ( 3794 b = 1, 3795 s = 2, 3796 i = 3, 3797 l = 4L, 3798 c = '5', 3799 f = 6.0f, 3800 d = 7.0, 3801 bool = true, 3802 str = "custom", 3803 cls = Map.class, 3804 e = Stooge.MOE, 3805 a = @Point(x = 1, y = 2) 3806 ) 3807 public int scalarTypesField; 3808 3809 @ScalarTypesWithDefault ( ) 3810 public int scalarTypesAcceptDefaultField; 3811 3812 @ScalarTypesWithDefault ( 3813 b = 1, 3814 s = 2, 3815 i = 3, 3816 l = 4L, 3817 c = '5', 3818 f = 6.0f, 3819 d = 7.0, 3820 bool = true, 3821 str = "custom", 3822 cls = Map.class, 3823 e = Stooge.MOE 3824 ) 3825 public int scalarTypesOverrideDefaultField; 3826 3827 @ArrayTypes ( 3828 b = { }, 3829 s = { }, 3830 i = { }, 3831 l = { }, 3832 c = { }, 3833 f = { }, 3834 d = { }, 3835 bool = { }, 3836 str = { }, 3837 cls = { }, 3838 e = { }, 3839 a = { } 3840 ) 3841 public int emptyArrayTypesField; 3842 3843 @ArrayTypes ( 3844 b = 1, 3845 s = 2, 3846 i = 3, 3847 l = 4L, 3848 c = '5', 3849 f = 6.0f, 3850 d = 7.0, 3851 bool = true, 3852 str = "custom", 3853 cls = Map.class, 3854 e = Stooge.MOE, 3855 a = { @Point(x = 1, y = 2) } 3856 ) 3857 public int singleElementArrayTypesField; 3858 3859 @ArrayTypes ( 3860 b = { 1, 2 }, 3861 s = { 2, 3 }, 3862 i = { 3, 4 }, 3863 l = { 4L, 5L }, 3864 c = { '5', '6' }, 3865 f = { 6.0f, 7.0f }, 3866 d = { 7.0, 8.0 }, 3867 bool = { true, false }, 3868 str = { "custom", "paint" }, 3869 cls = { Map.class, Set.class }, 3870 e = { Stooge.MOE, Stooge.CURLY }, 3871 a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) } 3872 ) 3873 public int twoElementArrayTypesField; 3874 3875 @ArrayTypesWithDefault ( ) 3876 public int arrayTypesAcceptDefaultField; 3877 3878 @ArrayTypesWithDefault ( 3879 b = 1, 3880 s = 2, 3881 i = 3, 3882 l = 4L, 3883 c = '5', 3884 f = 6.0f, 3885 d = 7.0, 3886 bool = true, 3887 str = "custom", 3888 cls = Map.class, 3889 e = Stooge.MOE, 3890 a = { @Point(x = 1, y = 2) } 3891 ) 3892 public int arrayTypesOverrideDefaultField; 3893 3894 @Marker public int markerField; 3895 3896 // Single-member (shorthand) 3897 @SingleMemberByte(1) public int SingleMemberByteField; 3898 @SingleMemberShort(2) public int SingleMemberShortField; 3899 @SingleMemberInt(3) public int SingleMemberIntField; 3900 @SingleMemberLong(4L) public int SingleMemberLongField; 3901 @SingleMemberChar('5') public int SingleMemberCharField; 3902 @SingleMemberFloat(6.0f) public int SingleMemberFloatField; 3903 @SingleMemberDouble(7.0) public int SingleMemberDoubleField; 3904 @SingleMemberBoolean(true) public int SingleMemberBooleanField; 3905 @SingleMemberString("custom") public int SingleMemberStringField; 3906 @SingleMemberClass(Map.class) public int SingleMemberClassField; 3907 @SingleMemberEnum(Stooge.MOE) public int SingleMemberEnumField; 3908 3909 // Single-member with default (Override) 3910 @SingleMemberByteWithDef(1) public int SingleMemberByteOvrdDefField; 3911 @SingleMemberShortWithDef(2) public int SingleMemberShortOvrdDefField; 3912 @SingleMemberIntWithDef(3) public int SingleMemberIntOvrdDefField; 3913 @SingleMemberLongWithDef(4L) public int SingleMemberLongOvrdDefField; 3914 @SingleMemberCharWithDef('5') public int SingleMemberCharOvrdDefField; 3915 @SingleMemberFloatWithDef(6.0f) public int SingleMemberFloatOvrdDefField; 3916 @SingleMemberDoubleWithDef(7.0) public int SingleMemberDoubleOvrdDefField; 3917 @SingleMemberBooleanWithDef(true) public int SingleMemberBooleanOvrdDefField; 3918 @SingleMemberStringWithDef("custom") public int SingleMemberStringOvrdDefField; 3919 @SingleMemberClassWithDef(Map.class) public int SingleMemberClassOvrdDefField; 3920 @SingleMemberEnumWithDef(Stooge.MOE) public int SingleMemberEnumOvrdDefField; 3921 3922 // Single-member with default (Accept) 3923 @SingleMemberByteWithDef public int SingleMemberByteAcceptDefField; 3924 @SingleMemberShortWithDef public int SingleMemberShortAcceptDefField; 3925 @SingleMemberIntWithDef public int SingleMemberIntAcceptDefField; 3926 @SingleMemberLongWithDef public int SingleMemberLongAcceptDefField; 3927 @SingleMemberCharWithDef public int SingleMemberCharAcceptDefField; 3928 @SingleMemberFloatWithDef public int SingleMemberFloatAcceptDefField; 3929 @SingleMemberDoubleWithDef public int SingleMemberDoubleAcceptDefField; 3930 @SingleMemberBooleanWithDef public int SingleMemberBooleanAcceptDefField; 3931 @SingleMemberStringWithDef public int SingleMemberStringAcceptDefField; 3932 @SingleMemberClassWithDef public int SingleMemberClassAcceptDefField; 3933 @SingleMemberEnumWithDef public int SingleMemberEnumAcceptDefField; 3934 3935 // Single member array (empty array) 3936 @SingleMemberByteArray({}) public int SingleMemberByteArrEmptyField; 3937 @SingleMemberShortArray({}) public int SingleMemberShortArrEmptyField; 3938 @SingleMemberIntArray({}) public int SingleMemberIntArrEmptyField; 3939 @SingleMemberLongArray({}) public int SingleMemberLongArrEmptyField; 3940 @SingleMemberCharArray({}) public int SingleMemberCharArrEmptyField; 3941 @SingleMemberFloatArray({}) public int SingleMemberFloatArrEmptyField; 3942 @SingleMemberDoubleArray({}) public int SingleMemberDoubleArrEmptyField; 3943 @SingleMemberBooleanArray({})public int SingleMemberBooleanArrEmptyField; 3944 @SingleMemberStringArray({}) public int SingleMemberStringArrEmptyField; 3945 @SingleMemberClassArray({}) public int SingleMemberClassArrEmptyField; 3946 @SingleMemberEnumArray({}) public int SingleMemberEnumArrEmptyField; 3947 3948 // Single member array (one-element shorthand) 3949 @SingleMemberByteArray(1) public int SingleMemberByteArrOneField; 3950 @SingleMemberShortArray(2) public int SingleMemberShortArrOneField; 3951 @SingleMemberIntArray(3) public int SingleMemberIntArrOneField; 3952 @SingleMemberLongArray(4L) public int SingleMemberLongArrOneField; 3953 @SingleMemberCharArray('5') public int SingleMemberCharArrOneField; 3954 @SingleMemberFloatArray(6.0f) public int SingleMemberFloatArrOneField; 3955 @SingleMemberDoubleArray(7.0) public int SingleMemberDoubleArrOneField; 3956 @SingleMemberBooleanArray(true) public int SingleMemberBooleanArrOneField; 3957 @SingleMemberStringArray("custom") public int SingleMemberStringArrOneField; 3958 @SingleMemberClassArray(Map.class) public int SingleMemberClassArrOneField; 3959 @SingleMemberEnumArray(Stooge.MOE) public int SingleMemberEnumArrOneField; 3960 3961 // Single member array (two elements) 3962 @SingleMemberByteArray({1, 2}) public int SingleMemberByteArrTwoField; 3963 @SingleMemberShortArray({2, 3}) public int SingleMemberShortArrTwoField; 3964 @SingleMemberIntArray({3, 4}) public int SingleMemberIntArrTwoField; 3965 @SingleMemberLongArray({4L, 5L}) public int SingleMemberLongArrTwoField; 3966 @SingleMemberCharArray({'5', '6'}) public int SingleMemberCharArrTwoField; 3967 @SingleMemberFloatArray({6.0f, 7.0f}) public int SingleMemberFloatArrTwoField; 3968 @SingleMemberDoubleArray({7.0, 8.0}) public int SingleMemberDoubleArrTwoField; 3969 @SingleMemberBooleanArray({true,false}) public int SingleMemberBooleanArrTwoField; 3970 @SingleMemberStringArray({"custom", "paint"}) public int SingleMemberStringArrTwoField; 3971 @SingleMemberClassArray({Map.class, Set.class}) public int SingleMemberClassArrTwoField; 3972 @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public int SingleMemberEnumArrTwoField; 3973 3974 // Single member array with default (override) 3975 @SingleMemberByteArrayDef(1) public int SingleMemberByteArrOvrdDefField; 3976 @SingleMemberShortArrayDef(2) public int SingleMemberShortArrOvrdDefField; 3977 @SingleMemberIntArrayDef(3) public int SingleMemberIntArrOvrdDefField; 3978 @SingleMemberLongArrayDef(4L) public int SingleMemberLongArrOvrdDefField; 3979 @SingleMemberCharArrayDef('5') public int SingleMemberCharArrOvrdDefField; 3980 @SingleMemberFloatArrayDef(6.0f) public int SingleMemberFloatArrOvrdDefField; 3981 @SingleMemberDoubleArrayDef(7.0) public int SingleMemberDoubleArrOvrdDefField; 3982 @SingleMemberBooleanArrayDef(true) public int SingleMemberBooleanArrOvrdDefField; 3983 @SingleMemberStringArrayDef("custom") public int SingleMemberStringArrOvrdDefField; 3984 @SingleMemberClassArrayDef(Map.class) public int SingleMemberClassArrOvrdDefField; 3985 @SingleMemberEnumArrayDef(Stooge.MOE) public int SingleMemberEnumArrOvrdDefField; 3986 3987 // Single member array with default - accept 3988 @SingleMemberByteArrayDef public int SingleMemberByteArrAcceptDefField; 3989 @SingleMemberShortArrayDef public int SingleMemberShortArrAcceptDefField; 3990 @SingleMemberIntArrayDef public int SingleMemberIntArrAcceptDefField; 3991 @SingleMemberLongArrayDef public int SingleMemberLongArrAcceptDefField; 3992 @SingleMemberCharArrayDef public int SingleMemberCharArrAcceptDefField; 3993 @SingleMemberFloatArrayDef public int SingleMemberFloatArrAcceptDefField; 3994 @SingleMemberDoubleArrayDef public int SingleMemberDoubleArrAcceptDefField; 3995 @SingleMemberBooleanArrayDef public int SingleMemberBooleanArrAcceptDefField; 3996 @SingleMemberStringArrayDef public int SingleMemberStringArrAcceptDefField; 3997 @SingleMemberClassArrayDef public int SingleMemberClassArrAcceptDefField; 3998 @SingleMemberEnumArrayDef public int SingleMemberEnumArrAcceptDefField; 3999 4000 // ANNOTATED ENUM CONSTANTS 4001 enum TestType { 4002 @ScalarTypes ( 4003 b = 1, 4004 s = 2, 4005 i = 3, 4006 l = 4L, 4007 c = '5', 4008 f = 6.0f, 4009 d = 7.0, 4010 bool = true, 4011 str = "custom", 4012 cls = Map.class, 4013 e = Stooge.MOE, 4014 a = @Point(x = 1, y = 2) 4015 ) 4016 scalarTypesField, 4017 4018 @ScalarTypesWithDefault ( ) 4019 scalarTypesAcceptDefaultField, 4020 4021 @ScalarTypesWithDefault ( 4022 b = 1, 4023 s = 2, 4024 i = 3, 4025 l = 4L, 4026 c = '5', 4027 f = 6.0f, 4028 d = 7.0, 4029 bool = true, 4030 str = "custom", 4031 cls = Map.class, 4032 e = Stooge.MOE 4033 ) 4034 scalarTypesOverrideDefaultField, 4035 4036 @ArrayTypes ( 4037 b = { }, 4038 s = { }, 4039 i = { }, 4040 l = { }, 4041 c = { }, 4042 f = { }, 4043 d = { }, 4044 bool = { }, 4045 str = { }, 4046 cls = { }, 4047 e = { }, 4048 a = { } 4049 ) 4050 emptyArrayTypesField, 4051 4052 @ArrayTypes ( 4053 b = 1, 4054 s = 2, 4055 i = 3, 4056 l = 4L, 4057 c = '5', 4058 f = 6.0f, 4059 d = 7.0, 4060 bool = true, 4061 str = "custom", 4062 cls = Map.class, 4063 e = Stooge.MOE, 4064 a = @Point(x = 1, y = 2) 4065 ) 4066 singleElementArrayTypesField, 4067 4068 @ArrayTypes ( 4069 b = { 1, 2 }, 4070 s = { 2, 3 }, 4071 i = { 3, 4 }, 4072 l = { 4L, 5L }, 4073 c = { '5', '6' }, 4074 f = { 6.0f, 7.0f }, 4075 d = { 7.0, 8.0 }, 4076 bool = { true, false }, 4077 str = { "custom", "paint" }, 4078 cls = { Map.class, Set.class }, 4079 e = { Stooge.MOE, Stooge.CURLY }, 4080 a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) } 4081 ) 4082 twoElementArrayTypesField, 4083 4084 @ArrayTypesWithDefault ( ) 4085 arrayTypesAcceptDefaultField, 4086 4087 @ArrayTypesWithDefault ( 4088 b = 1, 4089 s = 2, 4090 i = 3, 4091 l = 4L, 4092 c = '5', 4093 f = 6.0f, 4094 d = 7.0, 4095 bool = true, 4096 str = "custom", 4097 cls = Map.class, 4098 e = Stooge.MOE, 4099 a = { @Point(x = 1, y = 2) } 4100 ) 4101 arrayTypesOverrideDefaultField, 4102 4103 // marker 4104 @Marker marker, 4105 4106 // Single-member (shorthand) 4107 @SingleMemberByte(1) SingleMemberByte, 4108 @SingleMemberShort(2) SingleMemberShort, 4109 @SingleMemberInt(3) SingleMemberInt, 4110 @SingleMemberLong(4L) SingleMemberLong, 4111 @SingleMemberChar('5') SingleMemberChar, 4112 @SingleMemberFloat(6.0f) SingleMemberFloat, 4113 @SingleMemberDouble(7.0) SingleMemberDouble, 4114 @SingleMemberBoolean(true) SingleMemberBoolean, 4115 @SingleMemberString("custom") SingleMemberString, 4116 @SingleMemberClass(Map.class) SingleMemberClass, 4117 @SingleMemberEnum(Stooge.MOE) SingleMemberEnum, 4118 4119 // Single-member with default (Override) 4120 @SingleMemberByteWithDef(1) SingleMemberByteOvrdDef, 4121 @SingleMemberShortWithDef(2) SingleMemberShortOvrdDef, 4122 @SingleMemberIntWithDef(3) SingleMemberIntOvrdDef, 4123 @SingleMemberLongWithDef(4L) SingleMemberLongOvrdDef, 4124 @SingleMemberCharWithDef('5') SingleMemberCharOvrdDef, 4125 @SingleMemberFloatWithDef(6.0f) SingleMemberFloatOvrdDef, 4126 @SingleMemberDoubleWithDef(7.0) SingleMemberDoubleOvrdDef, 4127 @SingleMemberBooleanWithDef(true) SingleMemberBooleanOvrdDef, 4128 @SingleMemberStringWithDef("custom") SingleMemberStringOvrdDef, 4129 @SingleMemberClassWithDef(Map.class) SingleMemberClassOvrdDef, 4130 @SingleMemberEnumWithDef(Stooge.MOE) SingleMemberEnumOvrdDef, 4131 4132 // Single-member with default (Accept) 4133 @SingleMemberByteWithDef SingleMemberByteAcceptDef, 4134 @SingleMemberShortWithDef SingleMemberShortAcceptDef, 4135 @SingleMemberIntWithDef SingleMemberIntAcceptDef, 4136 @SingleMemberLongWithDef SingleMemberLongAcceptDef, 4137 @SingleMemberCharWithDef SingleMemberCharAcceptDef, 4138 @SingleMemberFloatWithDef SingleMemberFloatAcceptDef, 4139 @SingleMemberDoubleWithDef SingleMemberDoubleAcceptDef, 4140 @SingleMemberBooleanWithDef SingleMemberBooleanAcceptDef, 4141 @SingleMemberStringWithDef SingleMemberStringAcceptDef, 4142 @SingleMemberClassWithDef SingleMemberClassAcceptDef, 4143 @SingleMemberEnumWithDef SingleMemberEnumAcceptDef, 4144 4145 // Single member array (empty array) 4146 @SingleMemberByteArray({}) SingleMemberByteArrEmpty, 4147 @SingleMemberShortArray({}) SingleMemberShortArrEmpty, 4148 @SingleMemberIntArray({}) SingleMemberIntArrEmpty, 4149 @SingleMemberLongArray({}) SingleMemberLongArrEmpty, 4150 @SingleMemberCharArray({}) SingleMemberCharArrEmpty, 4151 @SingleMemberFloatArray({}) SingleMemberFloatArrEmpty, 4152 @SingleMemberDoubleArray({}) SingleMemberDoubleArrEmpty, 4153 @SingleMemberBooleanArray({})SingleMemberBooleanArrEmpty, 4154 @SingleMemberStringArray({}) SingleMemberStringArrEmpty, 4155 @SingleMemberClassArray({}) SingleMemberClassArrEmpty, 4156 @SingleMemberEnumArray({}) SingleMemberEnumArrEmpty, 4157 4158 // Single member array (one-element shorthand) 4159 @SingleMemberByteArray(1) SingleMemberByteArrOne, 4160 @SingleMemberShortArray(2) SingleMemberShortArrOne, 4161 @SingleMemberIntArray(3) SingleMemberIntArrOne, 4162 @SingleMemberLongArray(4L) SingleMemberLongArrOne, 4163 @SingleMemberCharArray('5') SingleMemberCharArrOne, 4164 @SingleMemberFloatArray(6.0f) SingleMemberFloatArrOne, 4165 @SingleMemberDoubleArray(7.0) SingleMemberDoubleArrOne, 4166 @SingleMemberBooleanArray(true) SingleMemberBooleanArrOne, 4167 @SingleMemberStringArray("custom") SingleMemberStringArrOne, 4168 @SingleMemberClassArray(Map.class) SingleMemberClassArrOne, 4169 @SingleMemberEnumArray(Stooge.MOE) SingleMemberEnumArrOne, 4170 4171 // Single member array (two elements) 4172 @SingleMemberByteArray({1, 2}) SingleMemberByteArrTwo, 4173 @SingleMemberShortArray({2, 3}) SingleMemberShortArrTwo, 4174 @SingleMemberIntArray({3, 4}) SingleMemberIntArrTwo, 4175 @SingleMemberLongArray({4L, 5L}) SingleMemberLongArrTwo, 4176 @SingleMemberCharArray({'5', '6'}) SingleMemberCharArrTwo, 4177 @SingleMemberFloatArray({6.0f, 7.0f}) SingleMemberFloatArrTwo, 4178 @SingleMemberDoubleArray({7.0, 8.0}) SingleMemberDoubleArrTwo, 4179 @SingleMemberBooleanArray({true,false}) SingleMemberBooleanArrTwo, 4180 @SingleMemberStringArray({"custom", "paint"}) SingleMemberStringArrTwo, 4181 @SingleMemberClassArray({Map.class, Set.class}) SingleMemberClassArrTwo, 4182 @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) SingleMemberEnumArrTwo, 4183 4184 // Single member array with default (override) 4185 @SingleMemberByteArrayDef(1) SingleMemberByteArrOvrdDef, 4186 @SingleMemberShortArrayDef(2) SingleMemberShortArrOvrdDef, 4187 @SingleMemberIntArrayDef(3) SingleMemberIntArrOvrdDef, 4188 @SingleMemberLongArrayDef(4L) SingleMemberLongArrOvrdDef, 4189 @SingleMemberCharArrayDef('5') SingleMemberCharArrOvrdDef, 4190 @SingleMemberFloatArrayDef(6.0f) SingleMemberFloatArrOvrdDef, 4191 @SingleMemberDoubleArrayDef(7.0) SingleMemberDoubleArrOvrdDef, 4192 @SingleMemberBooleanArrayDef(true) SingleMemberBooleanArrOvrdDef, 4193 @SingleMemberStringArrayDef("custom") SingleMemberStringArrOvrdDef, 4194 @SingleMemberClassArrayDef(Map.class) SingleMemberClassArrOvrdDef, 4195 @SingleMemberEnumArrayDef(Stooge.MOE) SingleMemberEnumArrOvrdDef, 4196 4197 // Single member array with default - accept 4198 @SingleMemberByteArrayDef SingleMemberByteArrAcceptDef, 4199 @SingleMemberShortArrayDef SingleMemberShortArrAcceptDef, 4200 @SingleMemberIntArrayDef SingleMemberIntArrAcceptDef, 4201 @SingleMemberLongArrayDef SingleMemberLongArrAcceptDef, 4202 @SingleMemberCharArrayDef SingleMemberCharArrAcceptDef, 4203 @SingleMemberFloatArrayDef SingleMemberFloatArrAcceptDef, 4204 @SingleMemberDoubleArrayDef SingleMemberDoubleArrAcceptDef, 4205 @SingleMemberBooleanArrayDef SingleMemberBooleanArrAcceptDef, 4206 @SingleMemberStringArrayDef SingleMemberStringArrAcceptDef, 4207 @SingleMemberClassArrayDef SingleMemberClassArrAcceptDef, 4208 @SingleMemberEnumArrayDef SingleMemberEnumArrAcceptDef, 4209 } 4210 4211 // ANNOTATED CONSTRUCTORS 4212 4213 @ScalarTypes ( 4214 b = 1, 4215 s = 2, 4216 i = 3, 4217 l = 4L, 4218 c = '5', 4219 f = 6.0f, 4220 d = 7.0, 4221 bool = true, 4222 str = "custom", 4223 cls = Map.class, 4224 e = Stooge.MOE, 4225 a = @Point(x = 1, y = 2) 4226 ) 4227 public UnitTest(Iterator it) { } // scalar types 4228 4229 @ScalarTypesWithDefault ( ) 4230 public UnitTest(Set s) { } // scalarTypesAcceptDefault 4231 4232 @ScalarTypesWithDefault ( 4233 b = 1, 4234 s = 2, 4235 i = 3, 4236 l = 4L, 4237 c = '5', 4238 f = 6.0f, 4239 d = 7.0, 4240 bool = true, 4241 str = "custom", 4242 cls = Map.class, 4243 e = Stooge.MOE 4244 ) 4245 public UnitTest(Map s) { } // scalarTypesOverrideDefault 4246 4247 @ArrayTypes ( 4248 b = { }, 4249 s = { }, 4250 i = { }, 4251 l = { }, 4252 c = { }, 4253 f = { }, 4254 d = { }, 4255 bool = { }, 4256 str = { }, 4257 cls = { }, 4258 e = { }, 4259 a = { } 4260 ) 4261 public UnitTest(List l){ } // emptyArrayTypes 4262 4263 @ArrayTypes ( 4264 b = 1, 4265 s = 2, 4266 i = 3, 4267 l = 4L, 4268 c = '5', 4269 f = 6.0f, 4270 d = 7.0, 4271 bool = true, 4272 str = "custom", 4273 cls = Map.class, 4274 e = Stooge.MOE, 4275 a = @Point(x = 1, y = 2) 4276 ) 4277 public UnitTest(Collection c) { } // singleElementArrayTypes 4278 4279 @ArrayTypes ( 4280 b = { 1, 2 }, 4281 s = { 2, 3 }, 4282 i = { 3, 4 }, 4283 l = { 4L, 5L }, 4284 c = { '5', '6' }, 4285 f = { 6.0f, 7.0f }, 4286 d = { 7.0, 8.0 }, 4287 bool = { true, false }, 4288 str = { "custom", "paint" }, 4289 cls = { Map.class, Set.class }, 4290 e = { Stooge.MOE, Stooge.CURLY }, 4291 a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) } 4292 ) 4293 public UnitTest(SortedSet ss) { } // twoElementArrayTypes 4294 4295 @ArrayTypesWithDefault ( ) 4296 public UnitTest(SortedMap sm) { } // arrayTypesAcceptDefault 4297 4298 @ArrayTypesWithDefault ( 4299 b = 1, 4300 s = 2, 4301 i = 3, 4302 l = 4L, 4303 c = '5', 4304 f = 6.0f, 4305 d = 7.0, 4306 bool = true, 4307 str = "custom", 4308 cls = Map.class, 4309 e = Stooge.MOE, 4310 a = { @Point(x = 1, y = 2) } 4311 ) 4312 public UnitTest(RandomAccess r) { } // arrayTypesOverrideDefault 4313 4314 // Marker 4315 @Marker public UnitTest() { } // marker 4316 4317 // Single-member (shorthand) 4318 @SingleMemberByte(1) public UnitTest(byte b) { } 4319 @SingleMemberShort(2) public UnitTest(short s) { } 4320 @SingleMemberInt(3) public UnitTest(int i) { } 4321 @SingleMemberLong(4L) public UnitTest(long l) { } 4322 @SingleMemberChar('5') public UnitTest(char c) { } 4323 @SingleMemberFloat(6.0f) public UnitTest(float f) { } 4324 @SingleMemberDouble(7.0) public UnitTest(double d) { } 4325 @SingleMemberBoolean(true) public UnitTest(boolean b) { } 4326 @SingleMemberString("custom") public UnitTest(String s) { } 4327 @SingleMemberClass(Map.class) public UnitTest(Class c) { } 4328 @SingleMemberEnum(Stooge.MOE) public UnitTest(Enum e) { } 4329 4330 // Single-member with default (Override) 4331 @SingleMemberByteWithDef(1) public UnitTest(byte b, Set s) { } 4332 @SingleMemberShortWithDef(2) public UnitTest(short s, Set x) { } 4333 @SingleMemberIntWithDef(3) public UnitTest(int i, Set s) { } 4334 @SingleMemberLongWithDef(4L) public UnitTest(long l, Set s) { } 4335 @SingleMemberCharWithDef('5') public UnitTest(char c, Set s) { } 4336 @SingleMemberFloatWithDef(6.0f) public UnitTest(float f, Set s) { } 4337 @SingleMemberDoubleWithDef(7.0) public UnitTest(double d, Set s) { } 4338 @SingleMemberBooleanWithDef(true) public UnitTest(boolean b, Set s) { } 4339 @SingleMemberStringWithDef("custom") public UnitTest(String s, Set x) { } 4340 @SingleMemberClassWithDef(Map.class) public UnitTest(Class c, Set s) { } 4341 @SingleMemberEnumWithDef(Stooge.MOE) public UnitTest(Enum e, Set s) { } 4342 4343 // Single-member with default (Accept) 4344 @SingleMemberByteWithDef public UnitTest(byte b, Map m) { } 4345 @SingleMemberShortWithDef public UnitTest(short s, Map m) { } 4346 @SingleMemberIntWithDef public UnitTest(int i, Map m) { } 4347 @SingleMemberLongWithDef public UnitTest(long l, Map m) { } 4348 @SingleMemberCharWithDef public UnitTest(char c, Map m) { } 4349 @SingleMemberFloatWithDef public UnitTest(float f, Map m) { } 4350 @SingleMemberDoubleWithDef public UnitTest(double d, Map m) { } 4351 @SingleMemberBooleanWithDef public UnitTest(boolean b, Map m) { } 4352 @SingleMemberStringWithDef public UnitTest(String s, Map m) { } 4353 @SingleMemberClassWithDef public UnitTest(Class c, Map m) { } 4354 @SingleMemberEnumWithDef public UnitTest(Enum e, Map m) { } 4355 4356 // Single member array (empty array) 4357 @SingleMemberByteArray({}) public UnitTest(byte[] b) { } 4358 @SingleMemberShortArray({}) public UnitTest(short[] s) { } 4359 @SingleMemberIntArray({}) public UnitTest(int[] i) { } 4360 @SingleMemberLongArray({}) public UnitTest(long[] l) { } 4361 @SingleMemberCharArray({}) public UnitTest(char[] c) { } 4362 @SingleMemberFloatArray({}) public UnitTest(float[] f) { } 4363 @SingleMemberDoubleArray({}) public UnitTest(double[] d) { } 4364 @SingleMemberBooleanArray({})public UnitTest(boolean[] b) { } 4365 @SingleMemberStringArray({}) public UnitTest(String[] s) { } 4366 @SingleMemberClassArray({}) public UnitTest(Class[] c) { } 4367 @SingleMemberEnumArray({}) public UnitTest(Enum[] e) { } 4368 4369 // Single member array (one-element shorthand) 4370 @SingleMemberByteArray(1) public UnitTest(byte[] b, Set s) { } 4371 @SingleMemberShortArray(2) public UnitTest(short[] s, Set x) { } 4372 @SingleMemberIntArray(3) public UnitTest(int[] i, Set s) { } 4373 @SingleMemberLongArray(4L) public UnitTest(long[] l, Set s) { } 4374 @SingleMemberCharArray('5') public UnitTest(char[] c, Set s) { } 4375 @SingleMemberFloatArray(6.0f) public UnitTest(float[] f, Set s) { } 4376 @SingleMemberDoubleArray(7.0) public UnitTest(double[] d, Set s) { } 4377 @SingleMemberBooleanArray(true) public UnitTest(boolean[] b, Set s) { } 4378 @SingleMemberStringArray("custom") public UnitTest(String[] s, Set x) { } 4379 @SingleMemberClassArray(Map.class) public UnitTest(Class[] c, Set s) { } 4380 @SingleMemberEnumArray(Stooge.MOE) public UnitTest(Enum[] e, Set s) { } 4381 4382 // Single member array (two elements) 4383 @SingleMemberByteArray({1, 2}) public UnitTest(byte[] b, Map m) { } 4384 @SingleMemberShortArray({2, 3}) public UnitTest(short[] s, Map m) { } 4385 @SingleMemberIntArray({3, 4}) public UnitTest(int[] i, Map m) { } 4386 @SingleMemberLongArray({4L, 5L}) public UnitTest(long[] l, Map m) { } 4387 @SingleMemberCharArray({'5', '6'}) public UnitTest(char[] c, Map m) { } 4388 @SingleMemberFloatArray({6.0f, 7.0f}) public UnitTest(float[] f, Map m) { } 4389 @SingleMemberDoubleArray({7.0, 8.0}) public UnitTest(double[] d, Map m) { } 4390 @SingleMemberBooleanArray({true, false}) public UnitTest(boolean[] b, Map m) { } 4391 @SingleMemberStringArray({"custom", "paint"}) public UnitTest(String[] s, Map m) { } 4392 @SingleMemberClassArray({Map.class,Set.class}) public UnitTest(Class[] c, Map m) { } 4393 @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public UnitTest(Enum[] e, Map m) { } 4394 4395 4396 // Single member array with default (override) 4397 @SingleMemberByteArrayDef(1) public UnitTest(byte[] b, List l) { } 4398 @SingleMemberShortArrayDef(2) public UnitTest(short[] s, List l) { } 4399 @SingleMemberIntArrayDef(3) public UnitTest(int[] i, List l) { } 4400 @SingleMemberLongArrayDef(4L) public UnitTest(long[] l, List x) { } 4401 @SingleMemberCharArrayDef('5') public UnitTest(char[] c, List l) { } 4402 @SingleMemberFloatArrayDef(6.0f) public UnitTest(float[] f, List l) { } 4403 @SingleMemberDoubleArrayDef(7.0) public UnitTest(double[] d, List l) { } 4404 @SingleMemberBooleanArrayDef(true) public UnitTest(boolean[] b, List l) { } 4405 @SingleMemberStringArrayDef("custom") public UnitTest(String[] s, List l) { } 4406 @SingleMemberClassArrayDef(Map.class) public UnitTest(Class[] c, List l) { } 4407 @SingleMemberEnumArrayDef(Stooge.MOE) public UnitTest(Enum[] e, List l) { } 4408 4409 // Single member array with default - accept 4410 @SingleMemberByteArrayDef public UnitTest(byte[] b, Collection c) { } 4411 @SingleMemberShortArrayDef public UnitTest(short[] s, Collection c) { } 4412 @SingleMemberIntArrayDef public UnitTest(int[] i, Collection c) { } 4413 @SingleMemberLongArrayDef public UnitTest(long[] l, Collection c) { } 4414 @SingleMemberCharArrayDef public UnitTest(char[] c, Collection x) { } 4415 @SingleMemberFloatArrayDef public UnitTest(float[] f, Collection c) { } 4416 @SingleMemberDoubleArrayDef public UnitTest(double[] d, Collection c) { } 4417 @SingleMemberBooleanArrayDef public UnitTest(boolean[] b, Collection c) { } 4418 @SingleMemberStringArrayDef public UnitTest(String[] s, Collection c) { } 4419 @SingleMemberClassArrayDef public UnitTest(Class[] c, Collection x) { } 4420 @SingleMemberEnumArrayDef public UnitTest(Enum[] e, Collection c) { } 4421 4422 // ANNOTATED PARAMETERS 4423 4424 public void scalarTypesParam( 4425 @ScalarTypes ( 4426 b = 1, 4427 s = 2, 4428 i = 3, 4429 l = 4L, 4430 c = '5', 4431 f = 6.0f, 4432 d = 7.0, 4433 bool = true, 4434 str = "custom", 4435 cls = Map.class, 4436 e = Stooge.MOE, 4437 a = @Point(x = 1, y = 2) 4438 ) 4439 int x) { } 4440 4441 4442 public void scalarTypesAcceptDefaultParam( 4443 @ScalarTypesWithDefault int x) { } 4444 4445 public void scalarTypesOverrideDefaultParam( 4446 @ScalarTypesWithDefault ( 4447 b = 1, 4448 s = 2, 4449 i = 3, 4450 l = 4L, 4451 c = '5', 4452 f = 6.0f, 4453 d = 7.0, 4454 bool = true, 4455 str = "custom", 4456 cls = Map.class, 4457 e = Stooge.MOE 4458 ) 4459 int x) { } 4460 4461 public void emptyArrayTypesParam( 4462 @ArrayTypes ( 4463 b = { }, 4464 s = { }, 4465 i = { }, 4466 l = { }, 4467 c = { }, 4468 f = { }, 4469 d = { }, 4470 bool = { }, 4471 str = { }, 4472 cls = { }, 4473 e = { }, 4474 a = { } 4475 ) 4476 int x) { } 4477 4478 public void singleElementArrayTypesParam( 4479 @ArrayTypes ( 4480 b = 1, 4481 s = 2, 4482 i = 3, 4483 l = 4L, 4484 c = '5', 4485 f = 6.0f, 4486 d = 7.0, 4487 bool = true, 4488 str = "custom", 4489 cls = Map.class, 4490 e = Stooge.MOE, 4491 a = @Point(x = 1, y = 2) 4492 ) 4493 int x) { } 4494 4495 public void twoElementArrayTypesParam( 4496 @ArrayTypes ( 4497 b = { 1, 2 }, 4498 s = { 2, 3 }, 4499 i = { 3, 4 }, 4500 l = { 4L, 5L }, 4501 c = { '5', '6' }, 4502 f = { 6.0f, 7.0f }, 4503 d = { 7.0, 8.0 }, 4504 bool = { true, false }, 4505 str = { "custom", "paint" }, 4506 cls = { Map.class, Set.class }, 4507 e = { Stooge.MOE, Stooge.CURLY }, 4508 a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) } 4509 ) 4510 int x) { } 4511 4512 public void arrayTypesAcceptDefaultParam( 4513 @ArrayTypesWithDefault 4514 int x) { } 4515 4516 public void arrayTypesOverrideDefaultParam( 4517 @ArrayTypesWithDefault ( 4518 b = 1, 4519 s = 2, 4520 i = 3, 4521 l = 4L, 4522 c = '5', 4523 f = 6.0f, 4524 d = 7.0, 4525 bool = true, 4526 str = "custom", 4527 cls = Map.class, 4528 e = Stooge.MOE, 4529 a = { @Point(x = 1, y = 2) } 4530 ) 4531 int x) { } 4532 4533 // Marker 4534 public void markerParam(@Marker int x) { } 4535 4536 // Single-member (shorthand) 4537 public void SingleMemberByteParam(@SingleMemberByte(1) int x) {} 4538 public void SingleMemberShortParam(@SingleMemberShort(2) int x) {} 4539 public void SingleMemberIntParam(@SingleMemberInt(3) int x) {} 4540 public void SingleMemberLongParam(@SingleMemberLong(4L) int x) {} 4541 public void SingleMemberCharParam(@SingleMemberChar('5') int x) {} 4542 public void SingleMemberFloatParam(@SingleMemberFloat(6.0f) int x) {} 4543 public void SingleMemberDoubleParam(@SingleMemberDouble(7.0) int x) {} 4544 public void SingleMemberBooleanParam(@SingleMemberBoolean(true) int x) {} 4545 public void SingleMemberStringParam(@SingleMemberString("custom") int x) {} 4546 public void SingleMemberClassParam(@SingleMemberClass(Map.class) int x) {} 4547 public void SingleMemberEnumParam(@SingleMemberEnum(Stooge.MOE) int x) {} 4548 4549 // Single-member with default (Override) 4550 public void SingleMemberByteOvrdDefParam(@SingleMemberByteWithDef(1) int x) {} 4551 public void SingleMemberShortOvrdDefParam(@SingleMemberShortWithDef(2) int x) {} 4552 public void SingleMemberIntOvrdDefParam(@SingleMemberIntWithDef(3) int x) {} 4553 public void SingleMemberLongOvrdDefParam(@SingleMemberLongWithDef(4L) int x) {} 4554 public void SingleMemberCharOvrdDefParam(@SingleMemberCharWithDef('5') int x) {} 4555 public void SingleMemberFloatOvrdDefParam(@SingleMemberFloatWithDef(6.0f) int x) {} 4556 public void SingleMemberDoubleOvrdDefParam(@SingleMemberDoubleWithDef(7.0) int x) {} 4557 public void SingleMemberBooleanOvrdDefParam(@SingleMemberBooleanWithDef(true) int x) {} 4558 public void SingleMemberStringOvrdDefParam(@SingleMemberStringWithDef("custom") int x) {} 4559 public void SingleMemberClassOvrdDefParam(@SingleMemberClassWithDef(Map.class) int x) {} 4560 public void SingleMemberEnumOvrdDefParam(@SingleMemberEnumWithDef(Stooge.MOE) int x) {} 4561 4562 // Single-member with default (Accept) 4563 public void SingleMemberByteAcceptDefParam(@SingleMemberByteWithDef int x) {} 4564 public void SingleMemberShortAcceptDefParam(@SingleMemberShortWithDef int x) {} 4565 public void SingleMemberIntAcceptDefParam(@SingleMemberIntWithDef int x) {} 4566 public void SingleMemberLongAcceptDefParam(@SingleMemberLongWithDef int x) {} 4567 public void SingleMemberCharAcceptDefParam(@SingleMemberCharWithDef int x) {} 4568 public void SingleMemberFloatAcceptDefParam(@SingleMemberFloatWithDef int x) {} 4569 public void SingleMemberDoubleAcceptDefParam(@SingleMemberDoubleWithDef int x) {} 4570 public void SingleMemberBooleanAcceptDefParam(@SingleMemberBooleanWithDef int x){} 4571 public void SingleMemberStringAcceptDefParam(@SingleMemberStringWithDef int x) {} 4572 public void SingleMemberClassAcceptDefParam(@SingleMemberClassWithDef int x) {} 4573 public void SingleMemberEnumAcceptDefParam(@SingleMemberEnumWithDef int x) {} 4574 4575 // Single member array (empty array) 4576 public void SingleMemberByteArrEmptyParam(@SingleMemberByteArray({}) int x) {} 4577 public void SingleMemberShortArrEmptyParam(@SingleMemberShortArray({}) int x) {} 4578 public void SingleMemberIntArrEmptyParam(@SingleMemberIntArray({}) int x) {} 4579 public void SingleMemberLongArrEmptyParam(@SingleMemberLongArray({}) int x) {} 4580 public void SingleMemberCharArrEmptyParam(@SingleMemberCharArray({}) int x) {} 4581 public void SingleMemberFloatArrEmptyParam(@SingleMemberFloatArray({}) int x) {} 4582 public void SingleMemberDoubleArrEmptyParam(@SingleMemberDoubleArray({}) int x) {} 4583 public void SingleMemberBooleanArrEmptyParam(@SingleMemberBooleanArray({}) int x) {} 4584 public void SingleMemberStringArrEmptyParam(@SingleMemberStringArray({}) int x) {} 4585 public void SingleMemberClassArrEmptyParam(@SingleMemberClassArray({}) int x) {} 4586 public void SingleMemberEnumArrEmptyParam(@SingleMemberEnumArray({}) int x) {} 4587 4588 // Single member array (one-element shorthand) 4589 public void SingleMemberByteArrOneParam(@SingleMemberByteArray(1) int x) {} 4590 public void SingleMemberShortArrOneParam(@SingleMemberShortArray(2) int x) {} 4591 public void SingleMemberIntArrOneParam(@SingleMemberIntArray(3) int x) {} 4592 public void SingleMemberLongArrOneParam(@SingleMemberLongArray(4L) int x) {} 4593 public void SingleMemberCharArrOneParam(@SingleMemberCharArray('5') int x) {} 4594 public void SingleMemberFloatArrOneParam(@SingleMemberFloatArray(6.0f) int x) {} 4595 public void SingleMemberDoubleArrOneParam(@SingleMemberDoubleArray(7.0) int x) {} 4596 public void SingleMemberBooleanArrOneParam(@SingleMemberBooleanArray(true) int x) {} 4597 public void SingleMemberStringArrOneParam(@SingleMemberStringArray("custom") int x) {} 4598 public void SingleMemberClassArrOneParam(@SingleMemberClassArray(Map.class) int x) {} 4599 public void SingleMemberEnumArrOneParam(@SingleMemberEnumArray(Stooge.MOE) int x) {} 4600 4601 // Single member array (two elements) 4602 public void SingleMemberByteArrTwoParam(@SingleMemberByteArray({1, 2}) int x) {} 4603 public void SingleMemberShortArrTwoParam(@SingleMemberShortArray({2, 3}) int x) {} 4604 public void SingleMemberIntArrTwoParam(@SingleMemberIntArray({3, 4}) int x) {} 4605 public void SingleMemberLongArrTwoParam(@SingleMemberLongArray({4L, 5L}) int x) {} 4606 public void SingleMemberCharArrTwoParam(@SingleMemberCharArray({'5', '6'}) int x) {} 4607 public void SingleMemberFloatArrTwoParam(@SingleMemberFloatArray({6.0f, 7.0f}) int x) {} 4608 public void SingleMemberDoubleArrTwoParam(@SingleMemberDoubleArray({7.0, 8.0}) int x) {} 4609 public void SingleMemberBooleanArrTwoParam(@SingleMemberBooleanArray({true, false}) int x){} 4610 public void SingleMemberStringArrTwoParam(@SingleMemberStringArray({"custom", "paint"}) int x) {} 4611 public void SingleMemberClassArrTwoParam(@SingleMemberClassArray({Map.class, Set.class}) int x) {} 4612 public void SingleMemberEnumArrTwoParam(@SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) int x) {} 4613 4614 // Single member array with default (override) 4615 public void SingleMemberByteArrOvrdDefParam(@SingleMemberByteArrayDef(1) int x) {} 4616 public void SingleMemberShortArrOvrdDefParam(@SingleMemberShortArrayDef(2) int x) {} 4617 public void SingleMemberIntArrOvrdDefParam(@SingleMemberIntArrayDef(3) int x) {} 4618 public void SingleMemberLongArrOvrdDefParam(@SingleMemberLongArrayDef(4L) int x) {} 4619 public void SingleMemberCharArrOvrdDefParam(@SingleMemberCharArrayDef('5') int x) {} 4620 public void SingleMemberFloatArrOvrdDefParam(@SingleMemberFloatArrayDef(6.0f) int x) {} 4621 public void SingleMemberDoubleArrOvrdDefParam(@SingleMemberDoubleArrayDef(7.0) int x) {} 4622 public void SingleMemberBooleanArrOvrdDefParam(@SingleMemberBooleanArrayDef(true) int x){} 4623 public void SingleMemberStringArrOvrdDefParam(@SingleMemberStringArrayDef("custom") int x) {} 4624 public void SingleMemberClassArrOvrdDefParam(@SingleMemberClassArrayDef(Map.class) int x) {} 4625 public void SingleMemberEnumArrOvrdDefParam(@SingleMemberEnumArrayDef(Stooge.MOE) int x) {} 4626 4627 // Single member array with default - accept 4628 public void SingleMemberByteArrAcceptDefParam(@SingleMemberByteArrayDef int x) {} 4629 public void SingleMemberShortArrAcceptDefParam(@SingleMemberShortArrayDef int x) {} 4630 public void SingleMemberIntArrAcceptDefParam(@SingleMemberIntArrayDef int x) {} 4631 public void SingleMemberLongArrAcceptDefParam(@SingleMemberLongArrayDef int x) {} 4632 public void SingleMemberCharArrAcceptDefParam(@SingleMemberCharArrayDef int x) {} 4633 public void SingleMemberFloatArrAcceptDefParam(@SingleMemberFloatArrayDef int x) {} 4634 public void SingleMemberDoubleArrAcceptDefParam(@SingleMemberDoubleArrayDef int x) {} 4635 public void SingleMemberBooleanArrAcceptDefParam(@SingleMemberBooleanArrayDef int x){} 4636 public void SingleMemberStringArrAcceptDefParam(@SingleMemberStringArrayDef int x) {} 4637 public void SingleMemberClassArrAcceptDefParam(@SingleMemberClassArrayDef int x) {} 4638 public void SingleMemberEnumArrAcceptDefParam(@SingleMemberEnumArrayDef int x) {} 4639 } 4640 4641 // Helper types 4642 4643 enum Stooge { LARRY, MOE, CURLY } 4644 4645 @Target({}) @interface Point { int x(); int y(); } 4646 4647 // ANNOTATION TYPES 4648 4649 @Retention(RUNTIME) @interface ScalarTypes { 4650 byte b(); 4651 short s(); 4652 int i(); 4653 long l(); 4654 char c(); 4655 float f(); 4656 double d(); 4657 boolean bool(); 4658 String str(); 4659 Class cls(); 4660 Stooge e(); 4661 Point a(); 4662 } 4663 4664 @Retention(RUNTIME) @interface ScalarTypesWithDefault { 4665 byte b() default 11; 4666 short s() default 12; 4667 int i() default 13; 4668 long l() default 14; 4669 char c() default 'V'; 4670 float f() default 16.0f; 4671 double d() default 17.0; 4672 boolean bool() default false; 4673 String str() default "default"; 4674 Class cls() default Class.class; 4675 Stooge e() default Stooge.LARRY; 4676 Point a() default @Point(x = 11, y = 12); 4677 } 4678 4679 @Retention(RUNTIME) @interface ArrayTypes { 4680 byte[] b(); 4681 short[] s(); 4682 int[] i(); 4683 long[] l(); 4684 char[] c(); 4685 float[] f(); 4686 double[] d(); 4687 boolean[] bool(); 4688 String[] str(); 4689 Class[] cls(); 4690 Stooge[] e(); 4691 Point[] a(); 4692 } 4693 4694 @Retention(RUNTIME) @interface ArrayTypesWithDefault { 4695 byte[] b() default { 11 }; 4696 short[] s() default { 12 }; 4697 int[] i() default { 13 }; 4698 long[] l() default { 14L }; 4699 char[] c() default { 'V' }; 4700 float[] f() default { 16.0f }; 4701 double[] d() default { 17.0 }; 4702 boolean[] bool() default { false }; 4703 String[] str() default { "default" }; 4704 Class[] cls() default { Class.class }; 4705 Stooge[] e() default { Stooge.LARRY }; 4706 Point[] a() default { @Point(x = 11, y = 12) }; 4707 } 4708 4709 @Retention(RUNTIME) @interface Marker { } 4710 4711 @Retention(RUNTIME) @interface SingleMemberByte { byte value(); } 4712 @Retention(RUNTIME) @interface SingleMemberShort { short value(); } 4713 @Retention(RUNTIME) @interface SingleMemberInt { int value(); } 4714 @Retention(RUNTIME) @interface SingleMemberLong { long value(); } 4715 @Retention(RUNTIME) @interface SingleMemberChar { char value(); } 4716 @Retention(RUNTIME) @interface SingleMemberFloat { float value(); } 4717 @Retention(RUNTIME) @interface SingleMemberDouble { double value(); } 4718 @Retention(RUNTIME) @interface SingleMemberBoolean { boolean value(); } 4719 @Retention(RUNTIME) @interface SingleMemberString { String value(); } 4720 @Retention(RUNTIME) @interface SingleMemberClass { Class value(); } 4721 @Retention(RUNTIME) @interface SingleMemberEnum { Stooge value(); } 4722 4723 @Retention(RUNTIME) @interface SingleMemberByteWithDef { byte value() default 11; } 4724 @Retention(RUNTIME) @interface SingleMemberShortWithDef { short value() default 12; } 4725 @Retention(RUNTIME) @interface SingleMemberIntWithDef { int value() default 13; } 4726 @Retention(RUNTIME) @interface SingleMemberLongWithDef { long value() default 14; } 4727 @Retention(RUNTIME) @interface SingleMemberCharWithDef { char value() default 'V'; } 4728 @Retention(RUNTIME) @interface SingleMemberFloatWithDef { float value() default 16.0f; } 4729 @Retention(RUNTIME) @interface SingleMemberDoubleWithDef { double value() default 17.0; } 4730 @Retention(RUNTIME) @interface SingleMemberBooleanWithDef { boolean value() default false; } 4731 @Retention(RUNTIME) @interface SingleMemberStringWithDef { String value() default "default"; } 4732 @Retention(RUNTIME) @interface SingleMemberClassWithDef { Class value() default Class.class; } 4733 @Retention(RUNTIME) @interface SingleMemberEnumWithDef { Stooge value() default Stooge.LARRY; } 4734 4735 @Retention(RUNTIME) @interface SingleMemberByteArray { byte[] value(); } 4736 @Retention(RUNTIME) @interface SingleMemberShortArray { short[] value(); } 4737 @Retention(RUNTIME) @interface SingleMemberIntArray { int[] value(); } 4738 @Retention(RUNTIME) @interface SingleMemberLongArray { long[] value(); } 4739 @Retention(RUNTIME) @interface SingleMemberCharArray { char[] value(); } 4740 @Retention(RUNTIME) @interface SingleMemberFloatArray { float[] value(); } 4741 @Retention(RUNTIME) @interface SingleMemberDoubleArray { double[] value(); } 4742 @Retention(RUNTIME) @interface SingleMemberBooleanArray { boolean[] value(); } 4743 @Retention(RUNTIME) @interface SingleMemberStringArray { String[] value(); } 4744 @Retention(RUNTIME) @interface SingleMemberClassArray { Class[] value(); } 4745 @Retention(RUNTIME) @interface SingleMemberEnumArray { Stooge[] value(); } 4746 4747 @Retention(RUNTIME) @interface SingleMemberByteArrayDef { byte[] value() default { 11 }; } 4748 @Retention(RUNTIME) @interface SingleMemberShortArrayDef { short[] value() default { 12 }; } 4749 @Retention(RUNTIME) @interface SingleMemberIntArrayDef { int[] value() default { 13 }; } 4750 @Retention(RUNTIME) @interface SingleMemberLongArrayDef { long[] value() default { 14 }; } 4751 @Retention(RUNTIME) @interface SingleMemberCharArrayDef { char[] value() default { 'V' }; } 4752 @Retention(RUNTIME) @interface SingleMemberFloatArrayDef { float[] value() default { 16.0f };} 4753 @Retention(RUNTIME) @interface SingleMemberDoubleArrayDef { double[] value() default { 17.0 }; } 4754 @Retention(RUNTIME) @interface SingleMemberBooleanArrayDef { boolean[] value() default { false };} 4755 @Retention(RUNTIME) @interface SingleMemberStringArrayDef { 4756 String[] value() default {"default"}; 4757 } 4758 @Retention(RUNTIME) @interface SingleMemberClassArrayDef { 4759 Class[] value() default {Class.class}; 4760 } 4761 @Retention(RUNTIME) @interface SingleMemberEnumArrayDef { 4762 Stooge[] value() default {Stooge.LARRY}; 4763 } 4764 4765 // Annotation types for inheritance and declared-annotations tests 4766 @Inherited @Retention(RUNTIME) @interface Foo { } 4767 @Retention(RUNTIME) @interface Bar { } 4768 4769 4770 // ANNOTATED CLASSES 4771 4772 @ScalarTypes ( 4773 b = 1, 4774 s = 2, 4775 i = 3, 4776 l = 4L, 4777 c = '5', 4778 f = 6.0f, 4779 d = 7.0, 4780 bool = true, 4781 str = "custom", 4782 cls = Map.class, 4783 e = Stooge.MOE, 4784 a = @Point(x = 1, y = 2) 4785 ) 4786 class scalarTypesClass { } 4787 4788 @ScalarTypesWithDefault ( ) 4789 class scalarTypesAcceptDefaultClass { } 4790 4791 @ScalarTypesWithDefault ( 4792 b = 1, 4793 s = 2, 4794 i = 3, 4795 l = 4L, 4796 c = '5', 4797 f = 6.0f, 4798 d = 7.0, 4799 bool = true, 4800 str = "custom", 4801 cls = Map.class, 4802 e = Stooge.MOE 4803 ) 4804 class scalarTypesOverrideDefaultClass { } 4805 4806 @ArrayTypes ( 4807 b = { }, 4808 s = { }, 4809 i = { }, 4810 l = { }, 4811 c = { }, 4812 f = { }, 4813 d = { }, 4814 bool = { }, 4815 str = { }, 4816 cls = { }, 4817 e = { }, 4818 a = { } 4819 ) 4820 class emptyArrayTypesClass { } 4821 4822 @ArrayTypes ( 4823 b = 1, 4824 s = 2, 4825 i = 3, 4826 l = 4L, 4827 c = '5', 4828 f = 6.0f, 4829 d = 7.0, 4830 bool = true, 4831 str = "custom", 4832 cls = Map.class, 4833 e = Stooge.MOE, 4834 a = @Point(x = 1, y = 2) 4835 ) 4836 class singleElementArrayTypesClass { } 4837 4838 @ArrayTypes ( 4839 b = { 1, 2 }, 4840 s = { 2, 3 }, 4841 i = { 3, 4 }, 4842 l = { 4L, 5L }, 4843 c = { '5', '6' }, 4844 f = { 6.0f, 7.0f }, 4845 d = { 7.0, 8.0 }, 4846 bool = { true, false }, 4847 str = { "custom", "paint" }, 4848 cls = { Map.class, Set.class }, 4849 e = { Stooge.MOE, Stooge.CURLY }, 4850 a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) } 4851 ) 4852 class twoElementArrayTypesClass { } 4853 4854 @ArrayTypesWithDefault ( 4855 ) 4856 class arrayTypesAcceptDefaultClass { } 4857 4858 @ArrayTypesWithDefault ( 4859 b = 1, 4860 s = 2, 4861 i = 3, 4862 l = 4L, 4863 c = '5', 4864 f = 6.0f, 4865 d = 7.0, 4866 bool = true, 4867 str = "custom", 4868 cls = Map.class, 4869 e = Stooge.MOE, 4870 a = { @Point(x = 1, y = 2) } 4871 ) 4872 class arrayTypesOverrideDefaultClass { } 4873 4874 @Marker class markerClass { } 4875 4876 // Single-member (shorthand) 4877 @SingleMemberByte(1) class SingleMemberByteClass { } 4878 @SingleMemberShort(2) class SingleMemberShortClass { } 4879 @SingleMemberInt(3) class SingleMemberIntClass { } 4880 @SingleMemberLong(4L) class SingleMemberLongClass { } 4881 @SingleMemberChar('5') class SingleMemberCharClass { } 4882 @SingleMemberFloat(6.0f) class SingleMemberFloatClass { } 4883 @SingleMemberDouble(7.0) class SingleMemberDoubleClass { } 4884 @SingleMemberBoolean(true) class SingleMemberBooleanClass { } 4885 @SingleMemberString("custom") class SingleMemberStringClass { } 4886 @SingleMemberClass(Map.class) class SingleMemberClassClass { } 4887 @SingleMemberEnum(Stooge.MOE) class SingleMemberEnumClass { } 4888 4889 // Single-member with default (Override) 4890 @SingleMemberByteWithDef(1) class SingleMemberByteOvrdDefClass { } 4891 @SingleMemberShortWithDef(2) class SingleMemberShortOvrdDefClass { } 4892 @SingleMemberIntWithDef(3) class SingleMemberIntOvrdDefClass { } 4893 @SingleMemberLongWithDef(4L) class SingleMemberLongOvrdDefClass { } 4894 @SingleMemberCharWithDef('5') class SingleMemberCharOvrdDefClass { } 4895 @SingleMemberFloatWithDef(6.0f) class SingleMemberFloatOvrdDefClass { } 4896 @SingleMemberDoubleWithDef(7.0) class SingleMemberDoubleOvrdDefClass { } 4897 @SingleMemberBooleanWithDef(true) class SingleMemberBooleanOvrdDefClass { } 4898 @SingleMemberStringWithDef("custom") class SingleMemberStringOvrdDefClass { } 4899 @SingleMemberClassWithDef(Map.class) class SingleMemberClassOvrdDefClass { } 4900 @SingleMemberEnumWithDef(Stooge.MOE) class SingleMemberEnumOvrdDefClass { } 4901 4902 // Single-member with default (Accept) 4903 @SingleMemberByteWithDef class SingleMemberByteAcceptDefClass { } 4904 @SingleMemberShortWithDef class SingleMemberShortAcceptDefClass { } 4905 @SingleMemberIntWithDef class SingleMemberIntAcceptDefClass { } 4906 @SingleMemberLongWithDef class SingleMemberLongAcceptDefClass { } 4907 @SingleMemberCharWithDef class SingleMemberCharAcceptDefClass { } 4908 @SingleMemberFloatWithDef class SingleMemberFloatAcceptDefClass { } 4909 @SingleMemberDoubleWithDef class SingleMemberDoubleAcceptDefClass { } 4910 @SingleMemberBooleanWithDef class SingleMemberBooleanAcceptDefClass { } 4911 @SingleMemberStringWithDef class SingleMemberStringAcceptDefClass { } 4912 @SingleMemberClassWithDef class SingleMemberClassAcceptDefClass { } 4913 @SingleMemberEnumWithDef class SingleMemberEnumAcceptDefClass { } 4914 4915 // Single member array (empty array) 4916 @SingleMemberByteArray({}) class SingleMemberByteArrEmptyClass { } 4917 @SingleMemberShortArray({}) class SingleMemberShortArrEmptyClass { } 4918 @SingleMemberIntArray({}) class SingleMemberIntArrEmptyClass { } 4919 @SingleMemberLongArray({}) class SingleMemberLongArrEmptyClass { } 4920 @SingleMemberCharArray({}) class SingleMemberCharArrEmptyClass { } 4921 @SingleMemberFloatArray({}) class SingleMemberFloatArrEmptyClass { } 4922 @SingleMemberDoubleArray({}) class SingleMemberDoubleArrEmptyClass { } 4923 @SingleMemberBooleanArray({})class SingleMemberBooleanArrEmptyClass { } 4924 @SingleMemberStringArray({}) class SingleMemberStringArrEmptyClass { } 4925 @SingleMemberClassArray({}) class SingleMemberClassArrEmptyClass { } 4926 @SingleMemberEnumArray({}) class SingleMemberEnumArrEmptyClass { } 4927 4928 // Single member array (one-element shorthand) 4929 @SingleMemberByteArray(1) class SingleMemberByteArrOneClass { } 4930 @SingleMemberShortArray(2) class SingleMemberShortArrOneClass { } 4931 @SingleMemberIntArray(3) class SingleMemberIntArrOneClass { } 4932 @SingleMemberLongArray(4L) class SingleMemberLongArrOneClass { } 4933 @SingleMemberCharArray('5') class SingleMemberCharArrOneClass { } 4934 @SingleMemberFloatArray(6.0f) class SingleMemberFloatArrOneClass { } 4935 @SingleMemberDoubleArray(7.0) class SingleMemberDoubleArrOneClass { } 4936 @SingleMemberBooleanArray(true) class SingleMemberBooleanArrOneClass { } 4937 @SingleMemberStringArray("custom") class SingleMemberStringArrOneClass { } 4938 @SingleMemberClassArray(Map.class) class SingleMemberClassArrOneClass { } 4939 @SingleMemberEnumArray(Stooge.MOE) class SingleMemberEnumArrOneClass { } 4940 4941 // Single member array (two elements) 4942 @SingleMemberByteArray({1, 2}) class SingleMemberByteArrTwoClass { } 4943 @SingleMemberShortArray({2, 3}) class SingleMemberShortArrTwoClass { } 4944 @SingleMemberIntArray({3, 4}) class SingleMemberIntArrTwoClass { } 4945 @SingleMemberLongArray({4L, 5L}) class SingleMemberLongArrTwoClass { } 4946 @SingleMemberCharArray({'5', '6'}) class SingleMemberCharArrTwoClass { } 4947 @SingleMemberFloatArray({6.0f, 7.0f}) class SingleMemberFloatArrTwoClass { } 4948 @SingleMemberDoubleArray({7.0, 8.0}) class SingleMemberDoubleArrTwoClass { } 4949 @SingleMemberBooleanArray({true,false}) class SingleMemberBooleanArrTwoClass { } 4950 @SingleMemberStringArray({"custom", "paint"}) class SingleMemberStringArrTwoClass { } 4951 @SingleMemberClassArray({Map.class, Set.class}) class SingleMemberClassArrTwoClass { } 4952 @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) class SingleMemberEnumArrTwoClass { } 4953 4954 // Single member array with default (override) 4955 @SingleMemberByteArrayDef(1) class SingleMemberByteArrOvrdDefClass { } 4956 @SingleMemberShortArrayDef(2) class SingleMemberShortArrOvrdDefClass { } 4957 @SingleMemberIntArrayDef(3) class SingleMemberIntArrOvrdDefClass { } 4958 @SingleMemberLongArrayDef(4L) class SingleMemberLongArrOvrdDefClass { } 4959 @SingleMemberCharArrayDef('5') class SingleMemberCharArrOvrdDefClass { } 4960 @SingleMemberFloatArrayDef(6.0f) class SingleMemberFloatArrOvrdDefClass { } 4961 @SingleMemberDoubleArrayDef(7.0) class SingleMemberDoubleArrOvrdDefClass { } 4962 @SingleMemberBooleanArrayDef(true) class SingleMemberBooleanArrOvrdDefClass { } 4963 @SingleMemberStringArrayDef("custom") class SingleMemberStringArrOvrdDefClass { } 4964 @SingleMemberClassArrayDef(Map.class) class SingleMemberClassArrOvrdDefClass { } 4965 @SingleMemberEnumArrayDef(Stooge.MOE) class SingleMemberEnumArrOvrdDefClass { } 4966 4967 // Single member array with default - accept 4968 @SingleMemberByteArrayDef class SingleMemberByteArrAcceptDefClass { } 4969 @SingleMemberShortArrayDef class SingleMemberShortArrAcceptDefClass { } 4970 @SingleMemberIntArrayDef class SingleMemberIntArrAcceptDefClass { } 4971 @SingleMemberLongArrayDef class SingleMemberLongArrAcceptDefClass { } 4972 @SingleMemberCharArrayDef class SingleMemberCharArrAcceptDefClass { } 4973 @SingleMemberFloatArrayDef class SingleMemberFloatArrAcceptDefClass { } 4974 @SingleMemberDoubleArrayDef class SingleMemberDoubleArrAcceptDefClass { } 4975 @SingleMemberBooleanArrayDef class SingleMemberBooleanArrAcceptDefClass { } 4976 @SingleMemberStringArrayDef class SingleMemberStringArrAcceptDefClass { } 4977 @SingleMemberClassArrayDef class SingleMemberClassArrAcceptDefClass { } 4978 @SingleMemberEnumArrayDef class SingleMemberEnumArrAcceptDefClass { } 4979 4980 // Annotated classes for inheritance and declared-annotations tests 4981 @Foo @Bar class Grandpa { } 4982 class Dad extends Grandpa { } 4983 @Bar class Son extends Dad { }