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