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