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