Quelle  UnitTest.java   Sprache: JAVA

/*
 * Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug     4906359 4963461 4965058 4965039 4986770
 * @summary Unit test for annotation reading
 * @author  Josh Bloch
 */

import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.*;
import java.util.*;
import java.lang.reflect.*;
import java.io.*;

public class UnitTest {
    private static final Class[] X = new Class[0];
    private static final Class[] Y = { int.class };

    static int numTests = 0;

    public static void main(String[] args) throws Exception {

        // *** TESTS ON ANNOTATED METHODS ***

        // MULTIMEMBER SCALAR TYPES ON METHOD
        checkScalarTypes(UnitTest.class.getMethod("scalarTypesMethod", X));
        checkScalarTypesOverrideDefault(UnitTest.class.getMethod("scalarTypesOverrideDefaultMethod", X));
        checkScalarTypesAcceptDefault(UnitTest.class.getMethod("scalarTypesAcceptDefaultMethod", X));

        // MULTIMEMBER ARRAY TYPES ON METHOD
        checkArrayTypes0(UnitTest.class.getMethod("emptyArrayTypesMethod", X));
        checkArrayTypes1(UnitTest.class.getMethod("singleElementArrayTypesMethod", X));
        checkArrayTypes2(UnitTest.class.getMethod("twoElementArrayTypesMethod", X));
        checkArrayTypesAcceptDefault(UnitTest.class.getMethod("arrayTypesAcceptDefaultMethod", X));
        checkArrayTypesOverrideDefault(UnitTest.class.getMethod("arrayTypesOverrideDefaultMethod", X));

        // MARKER TYPE ON METHOD
        checkMarker(UnitTest.class.getMethod("markerMethod", X));

        // SINGLE-MEMBER SCALAR TYPES ON METHOD
        checkSingleMemberByte(UnitTest.class.getMethod("SingleMemberByte", X));
        checkSingleMemberShort(UnitTest.class.getMethod("SingleMemberShort", X));
        checkSingleMemberInt(UnitTest.class.getMethod("SingleMemberInt", X));
        checkSingleMemberLong(UnitTest.class.getMethod("SingleMemberLong", X));
        checkSingleMemberChar(UnitTest.class.getMethod("SingleMemberChar", X));
        checkSingleMemberFloat(UnitTest.class.getMethod("SingleMemberFloat", X));
        checkSingleMemberDouble(UnitTest.class.getMethod("SingleMemberDouble", X));
        checkSingleMemberBoolean(UnitTest.class.getMethod("SingleMemberBoolean", X));
        checkSingleMemberString(UnitTest.class.getMethod("SingleMemberString", X));
        checkSingleMemberClass(UnitTest.class.getMethod("SingleMemberClass", X));
        checkSingleMemberEnum(UnitTest.class.getMethod("SingleMemberEnum", X));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON METHOD
        checkSingleMemberByteOvrdDef(UnitTest.class.getMethod("SingleMemberByteOvrdDef", X));
        checkSingleMemberShortOvrdDef(UnitTest.class.getMethod("SingleMemberShortOvrdDef", X));
        checkSingleMemberIntOvrdDef(UnitTest.class.getMethod("SingleMemberIntOvrdDef", X));
        checkSingleMemberLongOvrdDef(UnitTest.class.getMethod("SingleMemberLongOvrdDef", X));
        checkSingleMemberCharOvrdDef(UnitTest.class.getMethod("SingleMemberCharOvrdDef", X));
        checkSingleMemberFloatOvrdDef(UnitTest.class.getMethod("SingleMemberFloatOvrdDef", X));
        checkSingleMemberDoubleOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleOvrdDef", X));
        checkSingleMemberBooleanOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanOvrdDef", X));
        checkSingleMemberStringOvrdDef(UnitTest.class.getMethod("SingleMemberStringOvrdDef", X));
        checkSingleMemberClassOvrdDef(UnitTest.class.getMethod("SingleMemberClassOvrdDef", X));
        checkSingleMemberEnumOvrdDef(UnitTest.class.getMethod("SingleMemberEnumOvrdDef", X));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON METHOD
        checkSingleMemberByteAcceptDef(UnitTest.class.getMethod("SingleMemberByteAcceptDef", X));
        checkSingleMemberShortAcceptDef(UnitTest.class.getMethod("SingleMemberShortAcceptDef", X));
        checkSingleMemberIntAcceptDef(UnitTest.class.getMethod("SingleMemberIntAcceptDef", X));
        checkSingleMemberLongAcceptDef(UnitTest.class.getMethod("SingleMemberLongAcceptDef", X));
        checkSingleMemberCharAcceptDef(UnitTest.class.getMethod("SingleMemberCharAcceptDef", X));
        checkSingleMemberFloatAcceptDef(UnitTest.class.getMethod("SingleMemberFloatAcceptDef", X));
        checkSingleMemberDoubleAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleAcceptDef", X));
        checkSingleMemberBooleanAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanAcceptDef", X));
        checkSingleMemberStringAcceptDef(UnitTest.class.getMethod("SingleMemberStringAcceptDef", X));
        checkSingleMemberClassAcceptDef(UnitTest.class.getMethod("SingleMemberClassAcceptDef", X));
        checkSingleMemberEnumAcceptDef(UnitTest.class.getMethod("SingleMemberEnumAcceptDef", X));

        // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON METHOD
        checkSingleMemberByteArrEmpty(UnitTest.class.getMethod("SingleMemberByteArrEmpty", X));
        checkSingleMemberShortArrEmpty(UnitTest.class.getMethod("SingleMemberShortArrEmpty", X));
        checkSingleMemberIntArrEmpty(UnitTest.class.getMethod("SingleMemberIntArrEmpty", X));
        checkSingleMemberLongArrEmpty(UnitTest.class.getMethod("SingleMemberLongArrEmpty", X));
        checkSingleMemberCharArrEmpty(UnitTest.class.getMethod("SingleMemberCharArrEmpty", X));
        checkSingleMemberFloatArrEmpty(UnitTest.class.getMethod("SingleMemberFloatArrEmpty", X));
        checkSingleMemberDoubleArrEmpty(UnitTest.class.getMethod("SingleMemberDoubleArrEmpty", X));
        checkSingleMemberBooleanArrEmpty(UnitTest.class.getMethod("SingleMemberBooleanArrEmpty", X));
        checkSingleMemberStringArrEmpty(UnitTest.class.getMethod("SingleMemberStringArrEmpty", X));
        checkSingleMemberClassArrEmpty(UnitTest.class.getMethod("SingleMemberClassArrEmpty", X));
        checkSingleMemberEnumArrEmpty(UnitTest.class.getMethod("SingleMemberEnumArrEmpty", X));

        // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON METHOD
        checkSingleMemberByteArrOne(UnitTest.class.getMethod("SingleMemberByteArrOne", X));
        checkSingleMemberShortArrOne(UnitTest.class.getMethod("SingleMemberShortArrOne", X));
        checkSingleMemberIntArrOne(UnitTest.class.getMethod("SingleMemberIntArrOne", X));
        checkSingleMemberLongArrOne(UnitTest.class.getMethod("SingleMemberLongArrOne", X));
        checkSingleMemberCharArrOne(UnitTest.class.getMethod("SingleMemberCharArrOne", X));
        checkSingleMemberFloatArrOne(UnitTest.class.getMethod("SingleMemberFloatArrOne", X));
        checkSingleMemberDoubleArrOne(UnitTest.class.getMethod("SingleMemberDoubleArrOne", X));
        checkSingleMemberBooleanArrOne(UnitTest.class.getMethod("SingleMemberBooleanArrOne", X));
        checkSingleMemberStringArrOne(UnitTest.class.getMethod("SingleMemberStringArrOne", X));
        checkSingleMemberClassArrOne(UnitTest.class.getMethod("SingleMemberClassArrOne", X));
        checkSingleMemberEnumArrOne(UnitTest.class.getMethod("SingleMemberEnumArrOne", X));

        // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON METHOD
        checkSingleMemberByteArrTwo(UnitTest.class.getMethod("SingleMemberByteArrTwo", X));
        checkSingleMemberShortArrTwo(UnitTest.class.getMethod("SingleMemberShortArrTwo", X));
        checkSingleMemberIntArrTwo(UnitTest.class.getMethod("SingleMemberIntArrTwo", X));
        checkSingleMemberLongArrTwo(UnitTest.class.getMethod("SingleMemberLongArrTwo", X));
        checkSingleMemberCharArrTwo(UnitTest.class.getMethod("SingleMemberCharArrTwo", X));
        checkSingleMemberFloatArrTwo(UnitTest.class.getMethod("SingleMemberFloatArrTwo", X));
        checkSingleMemberDoubleArrTwo(UnitTest.class.getMethod("SingleMemberDoubleArrTwo", X));
        checkSingleMemberBooleanArrTwo(UnitTest.class.getMethod("SingleMemberBooleanArrTwo", X));
        checkSingleMemberStringArrTwo(UnitTest.class.getMethod("SingleMemberStringArrTwo", X));
        checkSingleMemberClassArrTwo(UnitTest.class.getMethod("SingleMemberClassArrTwo", X));
        checkSingleMemberEnumArrTwo(UnitTest.class.getMethod("SingleMemberEnumArrTwo", X));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON METHOD
        checkSingleMemberByteArrOvrdDef(UnitTest.class.getMethod("SingleMemberByteArrOvrdDef", X));
        checkSingleMemberShortArrOvrdDef(UnitTest.class.getMethod("SingleMemberShortArrOvrdDef", X));
        checkSingleMemberIntArrOvrdDef(UnitTest.class.getMethod("SingleMemberIntArrOvrdDef", X));
        checkSingleMemberLongArrOvrdDef(UnitTest.class.getMethod("SingleMemberLongArrOvrdDef", X));
        checkSingleMemberCharArrOvrdDef(UnitTest.class.getMethod("SingleMemberCharArrOvrdDef", X));
        checkSingleMemberFloatArrOvrdDef(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDef", X));
        checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDef", X));
        checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDef", X));
        checkSingleMemberStringArrOvrdDef(UnitTest.class.getMethod("SingleMemberStringArrOvrdDef", X));
        checkSingleMemberClassArrOvrdDef(UnitTest.class.getMethod("SingleMemberClassArrOvrdDef", X));
        checkSingleMemberEnumArrOvrdDef(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDef", X));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON METHOD
        checkSingleMemberByteArrAcceptDef(UnitTest.class.getMethod("SingleMemberByteArrAcceptDef", X));
        checkSingleMemberShortArrAcceptDef(UnitTest.class.getMethod("SingleMemberShortArrAcceptDef", X));
        checkSingleMemberIntArrAcceptDef(UnitTest.class.getMethod("SingleMemberIntArrAcceptDef", X));
        checkSingleMemberLongArrAcceptDef(UnitTest.class.getMethod("SingleMemberLongArrAcceptDef", X));
        checkSingleMemberCharArrAcceptDef(UnitTest.class.getMethod("SingleMemberCharArrAcceptDef", X));
        checkSingleMemberFloatArrAcceptDef(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDef", X));
        checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDef", X));
        checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDef", X));
        checkSingleMemberStringArrAcceptDef(UnitTest.class.getMethod("SingleMemberStringArrAcceptDef", X));
        checkSingleMemberClassArrAcceptDef(UnitTest.class.getMethod("SingleMemberClassArrAcceptDef", X));
        checkSingleMemberEnumArrAcceptDef(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDef", X));

        // *** TESTS ON ANNOTATED FIELDS ***

        // MULTIMEMBER SCALAR TYPES ON FIELD
        checkScalarTypes(UnitTest.class.getField("scalarTypesField"));
        checkScalarTypesAcceptDefault(UnitTest.class.getField("scalarTypesAcceptDefaultField"));
        checkScalarTypesOverrideDefault(UnitTest.class.getField("scalarTypesOverrideDefaultField"));

        // MULTIMEMBER ARRAY TYPES ON FIELD
        checkArrayTypes0(UnitTest.class.getField("emptyArrayTypesField"));
        checkArrayTypes1(UnitTest.class.getField("singleElementArrayTypesField"));
        checkArrayTypes2(UnitTest.class.getField("twoElementArrayTypesField"));
        checkArrayTypesAcceptDefault(UnitTest.class.getField("arrayTypesAcceptDefaultField"));
        checkArrayTypesOverrideDefault(UnitTest.class.getField("arrayTypesOverrideDefaultField"));

        // MARKER TYPE ON FIELD
        checkMarker(UnitTest.class.getField("markerField"));

        // SINGLE-MEMBER SCALAR TYPES ON FIELD
        checkSingleMemberByte(UnitTest.class.getField("SingleMemberByteField"));
        checkSingleMemberShort(UnitTest.class.getField("SingleMemberShortField"));
        checkSingleMemberInt(UnitTest.class.getField("SingleMemberIntField"));
        checkSingleMemberLong(UnitTest.class.getField("SingleMemberLongField"));
        checkSingleMemberChar(UnitTest.class.getField("SingleMemberCharField"));
        checkSingleMemberFloat(UnitTest.class.getField("SingleMemberFloatField"));
        checkSingleMemberDouble(UnitTest.class.getField("SingleMemberDoubleField"));
        checkSingleMemberBoolean(UnitTest.class.getField("SingleMemberBooleanField"));
        checkSingleMemberString(UnitTest.class.getField("SingleMemberStringField"));
        checkSingleMemberClass(UnitTest.class.getField("SingleMemberClassField"));
        checkSingleMemberEnum(UnitTest.class.getField("SingleMemberEnumField"));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON FIELD
        checkSingleMemberByteOvrdDef(UnitTest.class.getField("SingleMemberByteOvrdDefField"));
        checkSingleMemberShortOvrdDef(UnitTest.class.getField("SingleMemberShortOvrdDefField"));
        checkSingleMemberIntOvrdDef(UnitTest.class.getField("SingleMemberIntOvrdDefField"));
        checkSingleMemberLongOvrdDef(UnitTest.class.getField("SingleMemberLongOvrdDefField"));
        checkSingleMemberCharOvrdDef(UnitTest.class.getField("SingleMemberCharOvrdDefField"));
        checkSingleMemberFloatOvrdDef(UnitTest.class.getField("SingleMemberFloatOvrdDefField"));
        checkSingleMemberDoubleOvrdDef(UnitTest.class.getField("SingleMemberDoubleOvrdDefField"));
        checkSingleMemberBooleanOvrdDef(UnitTest.class.getField("SingleMemberBooleanOvrdDefField"));
        checkSingleMemberStringOvrdDef(UnitTest.class.getField("SingleMemberStringOvrdDefField"));
        checkSingleMemberClassOvrdDef(UnitTest.class.getField("SingleMemberClassOvrdDefField"));
        checkSingleMemberEnumOvrdDef(UnitTest.class.getField("SingleMemberEnumOvrdDefField"));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON FIELD
        checkSingleMemberByteAcceptDef(UnitTest.class.getField("SingleMemberByteAcceptDefField"));
        checkSingleMemberShortAcceptDef(UnitTest.class.getField("SingleMemberShortAcceptDefField"));
        checkSingleMemberIntAcceptDef(UnitTest.class.getField("SingleMemberIntAcceptDefField"));
        checkSingleMemberLongAcceptDef(UnitTest.class.getField("SingleMemberLongAcceptDefField"));
        checkSingleMemberCharAcceptDef(UnitTest.class.getField("SingleMemberCharAcceptDefField"));
        checkSingleMemberFloatAcceptDef(UnitTest.class.getField("SingleMemberFloatAcceptDefField"));
        checkSingleMemberDoubleAcceptDef(UnitTest.class.getField("SingleMemberDoubleAcceptDefField"));
        checkSingleMemberBooleanAcceptDef(UnitTest.class.getField("SingleMemberBooleanAcceptDefField"));
        checkSingleMemberStringAcceptDef(UnitTest.class.getField("SingleMemberStringAcceptDefField"));
        checkSingleMemberClassAcceptDef(UnitTest.class.getField("SingleMemberClassAcceptDefField"));
        checkSingleMemberEnumAcceptDef(UnitTest.class.getField("SingleMemberEnumAcceptDefField"));

        // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON FIELD
        checkSingleMemberByteArrEmpty(UnitTest.class.getField("SingleMemberByteArrEmptyField"));
        checkSingleMemberShortArrEmpty(UnitTest.class.getField("SingleMemberShortArrEmptyField"));
        checkSingleMemberIntArrEmpty(UnitTest.class.getField("SingleMemberIntArrEmptyField"));
        checkSingleMemberLongArrEmpty(UnitTest.class.getField("SingleMemberLongArrEmptyField"));
        checkSingleMemberCharArrEmpty(UnitTest.class.getField("SingleMemberCharArrEmptyField"));
        checkSingleMemberFloatArrEmpty(UnitTest.class.getField("SingleMemberFloatArrEmptyField"));
        checkSingleMemberDoubleArrEmpty(UnitTest.class.getField("SingleMemberDoubleArrEmptyField"));
        checkSingleMemberBooleanArrEmpty(UnitTest.class.getField("SingleMemberBooleanArrEmptyField"));
        checkSingleMemberStringArrEmpty(UnitTest.class.getField("SingleMemberStringArrEmptyField"));
        checkSingleMemberClassArrEmpty(UnitTest.class.getField("SingleMemberClassArrEmptyField"));
        checkSingleMemberEnumArrEmpty(UnitTest.class.getField("SingleMemberEnumArrEmptyField"));

        // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON FIELD
        checkSingleMemberByteArrOne(UnitTest.class.getField("SingleMemberByteArrOneField"));
        checkSingleMemberShortArrOne(UnitTest.class.getField("SingleMemberShortArrOneField"));
        checkSingleMemberIntArrOne(UnitTest.class.getField("SingleMemberIntArrOneField"));
        checkSingleMemberLongArrOne(UnitTest.class.getField("SingleMemberLongArrOneField"));
        checkSingleMemberCharArrOne(UnitTest.class.getField("SingleMemberCharArrOneField"));
        checkSingleMemberFloatArrOne(UnitTest.class.getField("SingleMemberFloatArrOneField"));
        checkSingleMemberDoubleArrOne(UnitTest.class.getField("SingleMemberDoubleArrOneField"));
        checkSingleMemberBooleanArrOne(UnitTest.class.getField("SingleMemberBooleanArrOneField"));
        checkSingleMemberStringArrOne(UnitTest.class.getField("SingleMemberStringArrOneField"));
        checkSingleMemberClassArrOne(UnitTest.class.getField("SingleMemberClassArrOneField"));
        checkSingleMemberEnumArrOne(UnitTest.class.getField("SingleMemberEnumArrOneField"));

        // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON FIELD
        checkSingleMemberByteArrTwo(UnitTest.class.getField("SingleMemberByteArrTwoField"));
        checkSingleMemberShortArrTwo(UnitTest.class.getField("SingleMemberShortArrTwoField"));
        checkSingleMemberIntArrTwo(UnitTest.class.getField("SingleMemberIntArrTwoField"));
        checkSingleMemberLongArrTwo(UnitTest.class.getField("SingleMemberLongArrTwoField"));
        checkSingleMemberCharArrTwo(UnitTest.class.getField("SingleMemberCharArrTwoField"));
        checkSingleMemberFloatArrTwo(UnitTest.class.getField("SingleMemberFloatArrTwoField"));
        checkSingleMemberDoubleArrTwo(UnitTest.class.getField("SingleMemberDoubleArrTwoField"));
        checkSingleMemberBooleanArrTwo(UnitTest.class.getField("SingleMemberBooleanArrTwoField"));
        checkSingleMemberStringArrTwo(UnitTest.class.getField("SingleMemberStringArrTwoField"));
        checkSingleMemberClassArrTwo(UnitTest.class.getField("SingleMemberClassArrTwoField"));
        checkSingleMemberEnumArrTwo(UnitTest.class.getField("SingleMemberEnumArrTwoField"));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON FIELD
        checkSingleMemberByteArrOvrdDef(UnitTest.class.getField("SingleMemberByteArrOvrdDefField"));
        checkSingleMemberShortArrOvrdDef(UnitTest.class.getField("SingleMemberShortArrOvrdDefField"));
        checkSingleMemberIntArrOvrdDef(UnitTest.class.getField("SingleMemberIntArrOvrdDefField"));
        checkSingleMemberLongArrOvrdDef(UnitTest.class.getField("SingleMemberLongArrOvrdDefField"));
        checkSingleMemberCharArrOvrdDef(UnitTest.class.getField("SingleMemberCharArrOvrdDefField"));
        checkSingleMemberFloatArrOvrdDef(UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"));
        checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"));
        checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"));
        checkSingleMemberStringArrOvrdDef(UnitTest.class.getField("SingleMemberStringArrOvrdDefField"));
        checkSingleMemberClassArrOvrdDef(UnitTest.class.getField("SingleMemberClassArrOvrdDefField"));
        checkSingleMemberEnumArrOvrdDef(UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON FIELD
        checkSingleMemberByteArrAcceptDef(UnitTest.class.getField("SingleMemberByteArrAcceptDefField"));
        checkSingleMemberShortArrAcceptDef(UnitTest.class.getField("SingleMemberShortArrAcceptDefField"));
        checkSingleMemberIntArrAcceptDef(UnitTest.class.getField("SingleMemberIntArrAcceptDefField"));
        checkSingleMemberLongArrAcceptDef(UnitTest.class.getField("SingleMemberLongArrAcceptDefField"));
        checkSingleMemberCharArrAcceptDef(UnitTest.class.getField("SingleMemberCharArrAcceptDefField"));
        checkSingleMemberFloatArrAcceptDef(UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"));
        checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"));
        checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"));
        checkSingleMemberStringArrAcceptDef(UnitTest.class.getField("SingleMemberStringArrAcceptDefField"));
        checkSingleMemberClassArrAcceptDef(UnitTest.class.getField("SingleMemberClassArrAcceptDefField"));
        checkSingleMemberEnumArrAcceptDef(UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"));

        // *** TESTS ON ANNOTATED ENUM CONSTS ***

        // MULTIMEMBER SCALAR TYPES ON ENUM CONST
        checkScalarTypes(TestType.class.getField("scalarTypesField"));
        checkScalarTypesAcceptDefault(TestType.class.getField("scalarTypesAcceptDefaultField"));
        checkScalarTypesOverrideDefault(TestType.class.getField("scalarTypesOverrideDefaultField"));

        // MULTIMEMBER ARRAY TYPES ON ENUM CONST
        checkArrayTypes0(TestType.class.getField("emptyArrayTypesField"));
        checkArrayTypes1(TestType.class.getField("singleElementArrayTypesField"));
        checkArrayTypes2(TestType.class.getField("twoElementArrayTypesField"));
        checkArrayTypesAcceptDefault(TestType.class.getField("arrayTypesAcceptDefaultField"));
        checkArrayTypesOverrideDefault(TestType.class.getField("arrayTypesOverrideDefaultField"));

        // MARKER TYPE ON CLASS
        checkMarker(TestType.class.getField("marker"));

        // SINGLE-MEMBER SCALAR TYPES ON CLASS
        checkSingleMemberByte(TestType.class.getField("SingleMemberByte"));
        checkSingleMemberShort(TestType.class.getField("SingleMemberShort"));
        checkSingleMemberInt(TestType.class.getField("SingleMemberInt"));
        checkSingleMemberLong(TestType.class.getField("SingleMemberLong"));
        checkSingleMemberChar(TestType.class.getField("SingleMemberChar"));
        checkSingleMemberFloat(TestType.class.getField("SingleMemberFloat"));
        checkSingleMemberDouble(TestType.class.getField("SingleMemberDouble"));
        checkSingleMemberBoolean(TestType.class.getField("SingleMemberBoolean"));
        checkSingleMemberString(TestType.class.getField("SingleMemberString"));
        checkSingleMemberClass(TestType.class.getField("SingleMemberClass"));
        checkSingleMemberEnum(TestType.class.getField("SingleMemberEnum"));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS
        checkSingleMemberByteOvrdDef(TestType.class.getField("SingleMemberByteOvrdDef"));
        checkSingleMemberShortOvrdDef(TestType.class.getField("SingleMemberShortOvrdDef"));
        checkSingleMemberIntOvrdDef(TestType.class.getField("SingleMemberIntOvrdDef"));
        checkSingleMemberLongOvrdDef(TestType.class.getField("SingleMemberLongOvrdDef"));
        checkSingleMemberCharOvrdDef(TestType.class.getField("SingleMemberCharOvrdDef"));
        checkSingleMemberFloatOvrdDef(TestType.class.getField("SingleMemberFloatOvrdDef"));
        checkSingleMemberDoubleOvrdDef(TestType.class.getField("SingleMemberDoubleOvrdDef"));
        checkSingleMemberBooleanOvrdDef(TestType.class.getField("SingleMemberBooleanOvrdDef"));
        checkSingleMemberStringOvrdDef(TestType.class.getField("SingleMemberStringOvrdDef"));
        checkSingleMemberClassOvrdDef(TestType.class.getField("SingleMemberClassOvrdDef"));
        checkSingleMemberEnumOvrdDef(TestType.class.getField("SingleMemberEnumOvrdDef"));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS
        checkSingleMemberByteAcceptDef(TestType.class.getField("SingleMemberByteAcceptDef"));
        checkSingleMemberShortAcceptDef(TestType.class.getField("SingleMemberShortAcceptDef"));
        checkSingleMemberIntAcceptDef(TestType.class.getField("SingleMemberIntAcceptDef"));
        checkSingleMemberLongAcceptDef(TestType.class.getField("SingleMemberLongAcceptDef"));
        checkSingleMemberCharAcceptDef(TestType.class.getField("SingleMemberCharAcceptDef"));
        checkSingleMemberFloatAcceptDef(TestType.class.getField("SingleMemberFloatAcceptDef"));
        checkSingleMemberDoubleAcceptDef(TestType.class.getField("SingleMemberDoubleAcceptDef"));
        checkSingleMemberBooleanAcceptDef(TestType.class.getField("SingleMemberBooleanAcceptDef"));
        checkSingleMemberStringAcceptDef(TestType.class.getField("SingleMemberStringAcceptDef"));
        checkSingleMemberClassAcceptDef(TestType.class.getField("SingleMemberClassAcceptDef"));
        checkSingleMemberEnumAcceptDef(TestType.class.getField("SingleMemberEnumAcceptDef"));

        // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("EMPTY ARRAY) ON CLASS
        checkSingleMemberByteArrEmpty(TestType.class.getField("SingleMemberByteArrEmpty"));
        checkSingleMemberShortArrEmpty(TestType.class.getField("SingleMemberShortArrEmpty"));
        checkSingleMemberIntArrEmpty(TestType.class.getField("SingleMemberIntArrEmpty"));
        checkSingleMemberLongArrEmpty(TestType.class.getField("SingleMemberLongArrEmpty"));
        checkSingleMemberCharArrEmpty(TestType.class.getField("SingleMemberCharArrEmpty"));
        checkSingleMemberFloatArrEmpty(TestType.class.getField("SingleMemberFloatArrEmpty"));
        checkSingleMemberDoubleArrEmpty(TestType.class.getField("SingleMemberDoubleArrEmpty"));
        checkSingleMemberBooleanArrEmpty(TestType.class.getField("SingleMemberBooleanArrEmpty"));
        checkSingleMemberStringArrEmpty(TestType.class.getField("SingleMemberStringArrEmpty"));
        checkSingleMemberClassArrEmpty(TestType.class.getField("SingleMemberClassArrEmpty"));
        checkSingleMemberEnumArrEmpty(TestType.class.getField("SingleMemberEnumArrEmpty"));

        // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("ONE-ELEMENT ARRAY) ON CLASS
        checkSingleMemberByteArrOne(TestType.class.getField("SingleMemberByteArrOne"));
        checkSingleMemberShortArrOne(TestType.class.getField("SingleMemberShortArrOne"));
        checkSingleMemberIntArrOne(TestType.class.getField("SingleMemberIntArrOne"));
        checkSingleMemberLongArrOne(TestType.class.getField("SingleMemberLongArrOne"));
        checkSingleMemberCharArrOne(TestType.class.getField("SingleMemberCharArrOne"));
        checkSingleMemberFloatArrOne(TestType.class.getField("SingleMemberFloatArrOne"));
        checkSingleMemberDoubleArrOne(TestType.class.getField("SingleMemberDoubleArrOne"));
        checkSingleMemberBooleanArrOne(TestType.class.getField("SingleMemberBooleanArrOne"));
        checkSingleMemberStringArrOne(TestType.class.getField("SingleMemberStringArrOne"));
        checkSingleMemberClassArrOne(TestType.class.getField("SingleMemberClassArrOne"));
        checkSingleMemberEnumArrOne(TestType.class.getField("SingleMemberEnumArrOne"));

        // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("TWO-ELEMENT ARRAY) ON CLASS
        checkSingleMemberByteArrTwo(TestType.class.getField("SingleMemberByteArrTwo"));
        checkSingleMemberShortArrTwo(TestType.class.getField("SingleMemberShortArrTwo"));
        checkSingleMemberIntArrTwo(TestType.class.getField("SingleMemberIntArrTwo"));
        checkSingleMemberLongArrTwo(TestType.class.getField("SingleMemberLongArrTwo"));
        checkSingleMemberCharArrTwo(TestType.class.getField("SingleMemberCharArrTwo"));
        checkSingleMemberFloatArrTwo(TestType.class.getField("SingleMemberFloatArrTwo"));
        checkSingleMemberDoubleArrTwo(TestType.class.getField("SingleMemberDoubleArrTwo"));
        checkSingleMemberBooleanArrTwo(TestType.class.getField("SingleMemberBooleanArrTwo"));
        checkSingleMemberStringArrTwo(TestType.class.getField("SingleMemberStringArrTwo"));
        checkSingleMemberClassArrTwo(TestType.class.getField("SingleMemberClassArrTwo"));
        checkSingleMemberEnumArrTwo(TestType.class.getField("SingleMemberEnumArrTwo"));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("OVERRIDE)ON CLASS
        checkSingleMemberByteArrOvrdDef(TestType.class.getField("SingleMemberByteArrOvrdDef"));
        checkSingleMemberShortArrOvrdDef(TestType.class.getField("SingleMemberShortArrOvrdDef"));
        checkSingleMemberIntArrOvrdDef(TestType.class.getField("SingleMemberIntArrOvrdDef"));
        checkSingleMemberLongArrOvrdDef(TestType.class.getField("SingleMemberLongArrOvrdDef"));
        checkSingleMemberCharArrOvrdDef(TestType.class.getField("SingleMemberCharArrOvrdDef"));
        checkSingleMemberFloatArrOvrdDef(TestType.class.getField("SingleMemberFloatArrOvrdDef"));
        checkSingleMemberDoubleArrOvrdDef(TestType.class.getField("SingleMemberDoubleArrOvrdDef"));
        checkSingleMemberBooleanArrOvrdDef(TestType.class.getField("SingleMemberBooleanArrOvrdDef"));
        checkSingleMemberStringArrOvrdDef(TestType.class.getField("SingleMemberStringArrOvrdDef"));
        checkSingleMemberClassArrOvrdDef(TestType.class.getField("SingleMemberClassArrOvrdDef"));
        checkSingleMemberEnumArrOvrdDef(TestType.class.getField("SingleMemberEnumArrOvrdDef"));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("ACCEPT)ON CLASS
        checkSingleMemberByteArrAcceptDef(TestType.class.getField("SingleMemberByteArrAcceptDef"));
        checkSingleMemberShortArrAcceptDef(TestType.class.getField("SingleMemberShortArrAcceptDef"));
        checkSingleMemberIntArrAcceptDef(TestType.class.getField("SingleMemberIntArrAcceptDef"));
        checkSingleMemberLongArrAcceptDef(TestType.class.getField("SingleMemberLongArrAcceptDef"));
        checkSingleMemberCharArrAcceptDef(TestType.class.getField("SingleMemberCharArrAcceptDef"));
        checkSingleMemberFloatArrAcceptDef(TestType.class.getField("SingleMemberFloatArrAcceptDef"));
        checkSingleMemberDoubleArrAcceptDef(TestType.class.getField("SingleMemberDoubleArrAcceptDef"));
        checkSingleMemberBooleanArrAcceptDef(TestType.class.getField("SingleMemberBooleanArrAcceptDef"));
        checkSingleMemberStringArrAcceptDef(TestType.class.getField("SingleMemberStringArrAcceptDef"));
        checkSingleMemberClassArrAcceptDef(TestType.class.getField("SingleMemberClassArrAcceptDef"));
        checkSingleMemberEnumArrAcceptDef(TestType.class.getField("SingleMemberEnumArrAcceptDef"));

        // *** TESTS ON ANNOTATED CONSTRUCTORS ***

        // MULTIMEMBER SCALAR TYPES ON CONSTRUCTOR
        checkScalarTypes(UnitTest.class.getConstructor(new Class[]{Iterator.class}));
        checkScalarTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{Map.class}));
        checkScalarTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{Set.class}));

        // MULTIMEMBER ARRAY TYPES ON CONSTRUCTOR
        checkArrayTypes0(UnitTest.class.getConstructor(new Class[]{List.class}));
        checkArrayTypes1(UnitTest.class.getConstructor(new Class[]{Collection.class}));
        checkArrayTypes2(UnitTest.class.getConstructor(new Class[]{SortedSet.class}));
        checkArrayTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{SortedMap.class}));
        checkArrayTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{RandomAccess.class}));

        // MARKER TYPE ON CONSTRUCTOR
        checkMarker(UnitTest.class.getConstructor(new Class[] { }));

        // SINGLE-MEMBER SCALAR TYPES ON CONSTRUCTOR
        checkSingleMemberByte(UnitTest.class.getConstructor(new Class[] { byte.class }));
        checkSingleMemberShort(UnitTest.class.getConstructor(new Class[] { short.class }));
        checkSingleMemberInt(UnitTest.class.getConstructor(new Class[] { int.class }));
        checkSingleMemberLong(UnitTest.class.getConstructor(new Class[] { long.class }));
        checkSingleMemberChar(UnitTest.class.getConstructor(new Class[] { char.class }));
        checkSingleMemberFloat(UnitTest.class.getConstructor(new Class[] { float.class }));
        checkSingleMemberDouble(UnitTest.class.getConstructor(new Class[] { double.class }));
        checkSingleMemberBoolean(UnitTest.class.getConstructor(new Class[] { boolean.class }));
        checkSingleMemberString(UnitTest.class.getConstructor(new Class[] { String.class }));
        checkSingleMemberClass(UnitTest.class.getConstructor(new Class[] { Class.class }));
        checkSingleMemberEnum(UnitTest.class.getConstructor(new Class[] { Enum.class }));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CONSTRUCTOR
        checkSingleMemberByteOvrdDef(UnitTest.class.getConstructor(new Class[] { byte.class, Set.class }));
        checkSingleMemberShortOvrdDef(UnitTest.class.getConstructor(new Class[] { short.class, Set.class }));
        checkSingleMemberIntOvrdDef(UnitTest.class.getConstructor(new Class[] { int.class, Set.class }));
        checkSingleMemberLongOvrdDef(UnitTest.class.getConstructor(new Class[] { long.class, Set.class }));
        checkSingleMemberCharOvrdDef(UnitTest.class.getConstructor(new Class[] { char.class, Set.class }));
        checkSingleMemberFloatOvrdDef(UnitTest.class.getConstructor(new Class[] { float.class, Set.class }));
        checkSingleMemberDoubleOvrdDef(UnitTest.class.getConstructor(new Class[] { double.class, Set.class }));
        checkSingleMemberBooleanOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Set.class }));
        checkSingleMemberStringOvrdDef(UnitTest.class.getConstructor(new Class[] { String.class, Set.class }));
        checkSingleMemberClassOvrdDef(UnitTest.class.getConstructor(new Class[] { Class.class, Set.class }));
        checkSingleMemberEnumOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Set.class }));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CONSTRUCTOR
        checkSingleMemberByteAcceptDef(UnitTest.class.getConstructor(new Class[] { byte.class, Map.class }));
        checkSingleMemberShortAcceptDef(UnitTest.class.getConstructor(new Class[] { short.class, Map.class }));
        checkSingleMemberIntAcceptDef(UnitTest.class.getConstructor(new Class[] { int.class, Map.class }));
        checkSingleMemberLongAcceptDef(UnitTest.class.getConstructor(new Class[] { long.class, Map.class }));
        checkSingleMemberCharAcceptDef(UnitTest.class.getConstructor(new Class[] { char.class, Map.class }));
        checkSingleMemberFloatAcceptDef(UnitTest.class.getConstructor(new Class[] { float.class, Map.class }));
        checkSingleMemberDoubleAcceptDef(UnitTest.class.getConstructor(new Class[] { double.class, Map.class }));
        checkSingleMemberBooleanAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Map.class }));
        checkSingleMemberStringAcceptDef(UnitTest.class.getConstructor(new Class[] { String.class, Map.class }));
        checkSingleMemberClassAcceptDef(UnitTest.class.getConstructor(new Class[] { Class.class, Map.class }));
        checkSingleMemberEnumAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Map.class }));

        // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CONSTRUCTOR
        checkSingleMemberByteArrEmpty(UnitTest.class.getConstructor(new Class[] { byte[].class }));
        checkSingleMemberShortArrEmpty(UnitTest.class.getConstructor(new Class[] { short[].class }));
        checkSingleMemberIntArrEmpty(UnitTest.class.getConstructor(new Class[] { int[].class }));
        checkSingleMemberLongArrEmpty(UnitTest.class.getConstructor(new Class[] { long[].class }));
        checkSingleMemberCharArrEmpty(UnitTest.class.getConstructor(new Class[] { char[].class }));
        checkSingleMemberFloatArrEmpty(UnitTest.class.getConstructor(new Class[] { float[].class }));
        checkSingleMemberDoubleArrEmpty(UnitTest.class.getConstructor(new Class[] { double[].class }));
        checkSingleMemberBooleanArrEmpty(UnitTest.class.getConstructor(new Class[] { boolean[].class }));
        checkSingleMemberStringArrEmpty(UnitTest.class.getConstructor(new Class[] { String[].class }));
        checkSingleMemberClassArrEmpty(UnitTest.class.getConstructor(new Class[] { Class[].class }));
        checkSingleMemberEnumArrEmpty(UnitTest.class.getConstructor(new Class[] { Enum[].class }));

        // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CONSTRUCTOR
        checkSingleMemberByteArrOne(UnitTest.class.getConstructor(new Class[] { byte[].class, Set.class }));
        checkSingleMemberShortArrOne(UnitTest.class.getConstructor(new Class[] { short[].class, Set.class }));
        checkSingleMemberIntArrOne(UnitTest.class.getConstructor(new Class[] { int[].class, Set.class }));
        checkSingleMemberLongArrOne(UnitTest.class.getConstructor(new Class[] { long[].class, Set.class }));
        checkSingleMemberCharArrOne(UnitTest.class.getConstructor(new Class[] { char[].class, Set.class }));
        checkSingleMemberFloatArrOne(UnitTest.class.getConstructor(new Class[] { float[].class, Set.class }));
        checkSingleMemberDoubleArrOne(UnitTest.class.getConstructor(new Class[] { double[].class, Set.class }));
        checkSingleMemberBooleanArrOne(UnitTest.class.getConstructor(new Class[] { boolean[].class, Set.class }));
        checkSingleMemberStringArrOne(UnitTest.class.getConstructor(new Class[] { String[].class, Set.class }));
        checkSingleMemberClassArrOne(UnitTest.class.getConstructor(new Class[] { Class[].class, Set.class }));
        checkSingleMemberEnumArrOne(UnitTest.class.getConstructor(new Class[] { Enum[].class, Set.class }));

        // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CONSTRUCTOR
        checkSingleMemberByteArrTwo(UnitTest.class.getConstructor(new Class[] { byte[].class, Map.class }));
        checkSingleMemberShortArrTwo(UnitTest.class.getConstructor(new Class[] { short[].class, Map.class }));
        checkSingleMemberIntArrTwo(UnitTest.class.getConstructor(new Class[] { int[].class, Map.class }));
        checkSingleMemberLongArrTwo(UnitTest.class.getConstructor(new Class[] { long[].class, Map.class }));
        checkSingleMemberCharArrTwo(UnitTest.class.getConstructor(new Class[] { char[].class, Map.class }));
        checkSingleMemberFloatArrTwo(UnitTest.class.getConstructor(new Class[] { float[].class, Map.class }));
        checkSingleMemberDoubleArrTwo(UnitTest.class.getConstructor(new Class[] { double[].class, Map.class }));
        checkSingleMemberBooleanArrTwo(UnitTest.class.getConstructor(new Class[] { boolean[].class, Map.class }));
        checkSingleMemberStringArrTwo(UnitTest.class.getConstructor(new Class[] { String[].class, Map.class }));
        checkSingleMemberClassArrTwo(UnitTest.class.getConstructor(new Class[] { Class[].class, Map.class }));
        checkSingleMemberEnumArrTwo(UnitTest.class.getConstructor(new Class[] { Enum[].class, Map.class }));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CONSTRUCTOR
        checkSingleMemberByteArrOvrdDef(UnitTest.class.getConstructor(new Class[] { byte[].class, List.class }));
        checkSingleMemberShortArrOvrdDef(UnitTest.class.getConstructor(new Class[] { short[].class, List.class }));
        checkSingleMemberIntArrOvrdDef(UnitTest.class.getConstructor(new Class[] { int[].class, List.class }));
        checkSingleMemberLongArrOvrdDef(UnitTest.class.getConstructor(new Class[] { long[].class, List.class }));
        checkSingleMemberCharArrOvrdDef(UnitTest.class.getConstructor(new Class[] { char[].class, List.class }));
        checkSingleMemberFloatArrOvrdDef(UnitTest.class.getConstructor(new Class[] { float[].class, List.class }));
        checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getConstructor(new Class[] { double[].class, List.class }));
        checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, List.class }));
        checkSingleMemberStringArrOvrdDef(UnitTest.class.getConstructor(new Class[] { String[].class, List.class }));
        checkSingleMemberClassArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Class[].class, List.class }));
        checkSingleMemberEnumArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, List.class }));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CONSTRUCTOR
        checkSingleMemberByteArrAcceptDef(UnitTest.class.getConstructor(new Class[] { byte[].class, Collection.class }));
        checkSingleMemberShortArrAcceptDef(UnitTest.class.getConstructor(new Class[] { short[].class, Collection.class }));
        checkSingleMemberIntArrAcceptDef(UnitTest.class.getConstructor(new Class[] { int[].class, Collection.class }));
        checkSingleMemberLongArrAcceptDef(UnitTest.class.getConstructor(new Class[] { long[].class, Collection.class }));
        checkSingleMemberCharArrAcceptDef(UnitTest.class.getConstructor(new Class[] { char[].class, Collection.class }));
        checkSingleMemberFloatArrAcceptDef(UnitTest.class.getConstructor(new Class[] { float[].class, Collection.class }));
        checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getConstructor(new Class[] { double[].class, Collection.class }));
        checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, Collection.class }));
        checkSingleMemberStringArrAcceptDef(UnitTest.class.getConstructor(new Class[] { String[].class, Collection.class }));
        checkSingleMemberClassArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Class[].class, Collection.class }));
        checkSingleMemberEnumArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, Collection.class }));

        // *** TESTS ON ANNOTATED PARAMETERS ***

        // MULTIMEMBER SCALAR TYPES ON PARAM
        checkScalarTypesParam(UnitTest.class.getMethod("scalarTypesParam", Y));
        checkScalarTypesOverrideDefaultParam(UnitTest.class.getMethod("scalarTypesOverrideDefaultParam", Y));
        checkScalarTypesAcceptDefaultParam(UnitTest.class.getMethod("scalarTypesAcceptDefaultParam", Y));

        // MULTIMEMBER ARRAY TYPES ON PARAM
        checkArrayTypes0Param(UnitTest.class.getMethod("emptyArrayTypesParam", Y));
        checkArrayTypes1Param(UnitTest.class.getMethod("singleElementArrayTypesParam", Y));
        checkArrayTypes2Param(UnitTest.class.getMethod("twoElementArrayTypesParam", Y));
        checkArrayTypesAcceptDefaultParam(UnitTest.class.getMethod("arrayTypesAcceptDefaultParam", Y));
        checkArrayTypesOverrideDefaultParam(UnitTest.class.getMethod("arrayTypesOverrideDefaultParam", Y));

        // MARKER TYPE ON PARAMETER
        checkMarkerParam(UnitTest.class.getMethod("markerParam", Y));

        // SINGLE-MEMBER SCALAR TYPES ON PARAMETER
        checkSingleMemberByteParam(UnitTest.class.getMethod("SingleMemberByteParam", Y));
        checkSingleMemberShortParam(UnitTest.class.getMethod("SingleMemberShortParam", Y));
        checkSingleMemberIntParam(UnitTest.class.getMethod("SingleMemberIntParam", Y));
        checkSingleMemberLongParam(UnitTest.class.getMethod("SingleMemberLongParam", Y));
        checkSingleMemberCharParam(UnitTest.class.getMethod("SingleMemberCharParam", Y));
        checkSingleMemberFloatParam(UnitTest.class.getMethod("SingleMemberFloatParam", Y));
        checkSingleMemberDoubleParam(UnitTest.class.getMethod("SingleMemberDoubleParam", Y));
        checkSingleMemberBooleanParam(UnitTest.class.getMethod("SingleMemberBooleanParam", Y));
        checkSingleMemberStringParam(UnitTest.class.getMethod("SingleMemberStringParam", Y));
        checkSingleMemberClassParam(UnitTest.class.getMethod("SingleMemberClassParam", Y));
        checkSingleMemberEnumParam(UnitTest.class.getMethod("SingleMemberEnumParam", Y));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON PARAMETER
        checkSingleMemberByteOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteOvrdDefParam", Y));
        checkSingleMemberShortOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortOvrdDefParam", Y));
        checkSingleMemberIntOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntOvrdDefParam", Y));
        checkSingleMemberLongOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongOvrdDefParam", Y));
        checkSingleMemberCharOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharOvrdDefParam", Y));
        checkSingleMemberFloatOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatOvrdDefParam", Y));
        checkSingleMemberDoubleOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleOvrdDefParam", Y));
        checkSingleMemberBooleanOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanOvrdDefParam", Y));
        checkSingleMemberStringOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringOvrdDefParam", Y));
        checkSingleMemberClassOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassOvrdDefParam", Y));
        checkSingleMemberEnumOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumOvrdDefParam", Y));

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON PARAMETER
        checkSingleMemberByteAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteAcceptDefParam", Y));
        checkSingleMemberShortAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortAcceptDefParam", Y));
        checkSingleMemberIntAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntAcceptDefParam", Y));
        checkSingleMemberLongAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongAcceptDefParam", Y));
        checkSingleMemberCharAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharAcceptDefParam", Y));
        checkSingleMemberFloatAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatAcceptDefParam", Y));
        checkSingleMemberDoubleAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleAcceptDefParam", Y));
        checkSingleMemberBooleanAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanAcceptDefParam", Y));
        checkSingleMemberStringAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringAcceptDefParam", Y));
        checkSingleMemberClassAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassAcceptDefParam", Y));
        checkSingleMemberEnumAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumAcceptDefParam", Y));

        // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("EMPTY ARRAY) ON PARAMETER
        checkSingleMemberByteArrEmptyParam(UnitTest.class.getMethod("SingleMemberByteArrEmptyParam", Y));
        checkSingleMemberShortArrEmptyParam(UnitTest.class.getMethod("SingleMemberShortArrEmptyParam", Y));
        checkSingleMemberIntArrEmptyParam(UnitTest.class.getMethod("SingleMemberIntArrEmptyParam", Y));
        checkSingleMemberLongArrEmptyParam(UnitTest.class.getMethod("SingleMemberLongArrEmptyParam", Y));
        checkSingleMemberCharArrEmptyParam(UnitTest.class.getMethod("SingleMemberCharArrEmptyParam", Y));
        checkSingleMemberFloatArrEmptyParam(UnitTest.class.getMethod("SingleMemberFloatArrEmptyParam", Y));
        checkSingleMemberDoubleArrEmptyParam(UnitTest.class.getMethod("SingleMemberDoubleArrEmptyParam", Y));
        checkSingleMemberBooleanArrEmptyParam(UnitTest.class.getMethod("SingleMemberBooleanArrEmptyParam", Y));
        checkSingleMemberStringArrEmptyParam(UnitTest.class.getMethod("SingleMemberStringArrEmptyParam", Y));
        checkSingleMemberClassArrEmptyParam(UnitTest.class.getMethod("SingleMemberClassArrEmptyParam", Y));
        checkSingleMemberEnumArrEmptyParam(UnitTest.class.getMethod("SingleMemberEnumArrEmptyParam", Y));

        // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("ONE-ELEMENT ARRAY) ON PARAMETER
        checkSingleMemberByteArrOneParam(UnitTest.class.getMethod("SingleMemberByteArrOneParam", Y));
        checkSingleMemberShortArrOneParam(UnitTest.class.getMethod("SingleMemberShortArrOneParam", Y));
        checkSingleMemberIntArrOneParam(UnitTest.class.getMethod("SingleMemberIntArrOneParam", Y));
        checkSingleMemberLongArrOneParam(UnitTest.class.getMethod("SingleMemberLongArrOneParam", Y));
        checkSingleMemberCharArrOneParam(UnitTest.class.getMethod("SingleMemberCharArrOneParam", Y));
        checkSingleMemberFloatArrOneParam(UnitTest.class.getMethod("SingleMemberFloatArrOneParam", Y));
        checkSingleMemberDoubleArrOneParam(UnitTest.class.getMethod("SingleMemberDoubleArrOneParam", Y));
        checkSingleMemberBooleanArrOneParam(UnitTest.class.getMethod("SingleMemberBooleanArrOneParam", Y));
        checkSingleMemberStringArrOneParam(UnitTest.class.getMethod("SingleMemberStringArrOneParam", Y));
        checkSingleMemberClassArrOneParam(UnitTest.class.getMethod("SingleMemberClassArrOneParam", Y));
        checkSingleMemberEnumArrOneParam(UnitTest.class.getMethod("SingleMemberEnumArrOneParam", Y));

        // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("TWO-ELEMENT ARRAY) ON PARAMETER
        checkSingleMemberByteArrTwoParam(UnitTest.class.getMethod("SingleMemberByteArrTwoParam", Y));
        checkSingleMemberShortArrTwoParam(UnitTest.class.getMethod("SingleMemberShortArrTwoParam", Y));
        checkSingleMemberIntArrTwoParam(UnitTest.class.getMethod("SingleMemberIntArrTwoParam", Y));
        checkSingleMemberLongArrTwoParam(UnitTest.class.getMethod("SingleMemberLongArrTwoParam", Y));
        checkSingleMemberCharArrTwoParam(UnitTest.class.getMethod("SingleMemberCharArrTwoParam", Y));
        checkSingleMemberFloatArrTwoParam(UnitTest.class.getMethod("SingleMemberFloatArrTwoParam", Y));
        checkSingleMemberDoubleArrTwoParam(UnitTest.class.getMethod("SingleMemberDoubleArrTwoParam", Y));
        checkSingleMemberBooleanArrTwoParam(UnitTest.class.getMethod("SingleMemberBooleanArrTwoParam", Y));
        checkSingleMemberStringArrTwoParam(UnitTest.class.getMethod("SingleMemberStringArrTwoParam", Y));
        checkSingleMemberClassArrTwoParam(UnitTest.class.getMethod("SingleMemberClassArrTwoParam", Y));
        checkSingleMemberEnumArrTwoParam(UnitTest.class.getMethod("SingleMemberEnumArrTwoParam", Y));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("OVERRIDE)ON PARAMETER
        checkSingleMemberByteArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteArrOvrdDefParam", Y));
        checkSingleMemberShortArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortArrOvrdDefParam", Y));
        checkSingleMemberIntArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntArrOvrdDefParam", Y));
        checkSingleMemberLongArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongArrOvrdDefParam", Y));
        checkSingleMemberCharArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharArrOvrdDefParam", Y));
        checkSingleMemberFloatArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDefParam", Y));
        checkSingleMemberDoubleArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDefParam", Y));
        checkSingleMemberBooleanArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDefParam", Y));
        checkSingleMemberStringArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringArrOvrdDefParam", Y));
        checkSingleMemberClassArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassArrOvrdDefParam", Y));
        checkSingleMemberEnumArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDefParam", Y));

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("ACCEPT)ON PARAMETER
        checkSingleMemberByteArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteArrAcceptDefParam", Y));
        checkSingleMemberShortArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortArrAcceptDefParam", Y));
        checkSingleMemberIntArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntArrAcceptDefParam", Y));
        checkSingleMemberLongArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongArrAcceptDefParam", Y));
        checkSingleMemberCharArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharArrAcceptDefParam", Y));
        checkSingleMemberFloatArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDefParam", Y));
        checkSingleMemberDoubleArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDefParam", Y));
        checkSingleMemberBooleanArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDefParam", Y));
        checkSingleMemberStringArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringArrAcceptDefParam", Y));
        checkSingleMemberClassArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassArrAcceptDefParam", Y));
        checkSingleMemberEnumArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDefParam", Y));

        // *** TESTS ON ANNOTATED CLASSES ***

        // MULTIMEMBER SCALAR TYPES ON CLASS
        checkScalarTypes(scalarTypesClass.class);
        checkScalarTypesOverrideDefault(scalarTypesOverrideDefaultClass.class);
        checkScalarTypesAcceptDefault(scalarTypesAcceptDefaultClass.class);

        // MULTIMEMBER ARRAY TYPES ON CLASS
        checkArrayTypes0(emptyArrayTypesClass.class);
        checkArrayTypes1(singleElementArrayTypesClass.class);
        checkArrayTypes2(twoElementArrayTypesClass.class);
        checkArrayTypesOverrideDefault(arrayTypesOverrideDefaultClass.class);
        checkArrayTypesAcceptDefault(arrayTypesAcceptDefaultClass.class);

        // MARKER TYPE ON CLASS
        checkMarker(markerClass.class);

        // SINGLE-MEMBER SCALAR TYPES ON CLASS
        checkSingleMemberByte(SingleMemberByteClass.class);
        checkSingleMemberShort(SingleMemberShortClass.class);
        checkSingleMemberInt(SingleMemberIntClass.class);
        checkSingleMemberLong(SingleMemberLongClass.class);
        checkSingleMemberChar(SingleMemberCharClass.class);
        checkSingleMemberFloat(SingleMemberFloatClass.class);
        checkSingleMemberDouble(SingleMemberDoubleClass.class);
        checkSingleMemberBoolean(SingleMemberBooleanClass.class);
        checkSingleMemberString(SingleMemberStringClass.class);
        checkSingleMemberClass(SingleMemberClassClass.class);
        checkSingleMemberEnum(SingleMemberEnumClass.class);

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS
        checkSingleMemberByteOvrdDef(SingleMemberByteOvrdDefClass.class);
        checkSingleMemberShortOvrdDef(SingleMemberShortOvrdDefClass.class);
        checkSingleMemberIntOvrdDef(SingleMemberIntOvrdDefClass.class);
        checkSingleMemberLongOvrdDef(SingleMemberLongOvrdDefClass.class);
        checkSingleMemberCharOvrdDef(SingleMemberCharOvrdDefClass.class);
        checkSingleMemberFloatOvrdDef(SingleMemberFloatOvrdDefClass.class);
        checkSingleMemberDoubleOvrdDef(SingleMemberDoubleOvrdDefClass.class);
        checkSingleMemberBooleanOvrdDef(SingleMemberBooleanOvrdDefClass.class);
        checkSingleMemberStringOvrdDef(SingleMemberStringOvrdDefClass.class);
        checkSingleMemberClassOvrdDef(SingleMemberClassOvrdDefClass.class);
        checkSingleMemberEnumOvrdDef(SingleMemberEnumOvrdDefClass.class);

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS
        checkSingleMemberByteAcceptDef(SingleMemberByteAcceptDefClass.class);
        checkSingleMemberShortAcceptDef(SingleMemberShortAcceptDefClass.class);
        checkSingleMemberIntAcceptDef(SingleMemberIntAcceptDefClass.class);
        checkSingleMemberLongAcceptDef(SingleMemberLongAcceptDefClass.class);
        checkSingleMemberCharAcceptDef(SingleMemberCharAcceptDefClass.class);
        checkSingleMemberFloatAcceptDef(SingleMemberFloatAcceptDefClass.class);
        checkSingleMemberDoubleAcceptDef(SingleMemberDoubleAcceptDefClass.class);
        checkSingleMemberBooleanAcceptDef(SingleMemberBooleanAcceptDefClass.class);
        checkSingleMemberStringAcceptDef(SingleMemberStringAcceptDefClass.class);
        checkSingleMemberClassAcceptDef(SingleMemberClassAcceptDefClass.class);
        checkSingleMemberEnumAcceptDef(SingleMemberEnumAcceptDefClass.class);

        // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CLASS
        checkSingleMemberByteArrEmpty(SingleMemberByteArrEmptyClass.class);
        checkSingleMemberShortArrEmpty(SingleMemberShortArrEmptyClass.class);
        checkSingleMemberIntArrEmpty(SingleMemberIntArrEmptyClass.class);
        checkSingleMemberLongArrEmpty(SingleMemberLongArrEmptyClass.class);
        checkSingleMemberCharArrEmpty(SingleMemberCharArrEmptyClass.class);
        checkSingleMemberFloatArrEmpty(SingleMemberFloatArrEmptyClass.class);
        checkSingleMemberDoubleArrEmpty(SingleMemberDoubleArrEmptyClass.class);
        checkSingleMemberBooleanArrEmpty(SingleMemberBooleanArrEmptyClass.class);
        checkSingleMemberStringArrEmpty(SingleMemberStringArrEmptyClass.class);
        checkSingleMemberClassArrEmpty(SingleMemberClassArrEmptyClass.class);
        checkSingleMemberEnumArrEmpty(SingleMemberEnumArrEmptyClass.class);

        // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CLASS
        checkSingleMemberByteArrOne(SingleMemberByteArrOneClass.class);
        checkSingleMemberShortArrOne(SingleMemberShortArrOneClass.class);
        checkSingleMemberIntArrOne(SingleMemberIntArrOneClass.class);
        checkSingleMemberLongArrOne(SingleMemberLongArrOneClass.class);
        checkSingleMemberCharArrOne(SingleMemberCharArrOneClass.class);
        checkSingleMemberFloatArrOne(SingleMemberFloatArrOneClass.class);
        checkSingleMemberDoubleArrOne(SingleMemberDoubleArrOneClass.class);
        checkSingleMemberBooleanArrOne(SingleMemberBooleanArrOneClass.class);
        checkSingleMemberStringArrOne(SingleMemberStringArrOneClass.class);
        checkSingleMemberClassArrOne(SingleMemberClassArrOneClass.class);
        checkSingleMemberEnumArrOne(SingleMemberEnumArrOneClass.class);

        // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CLASS
        checkSingleMemberByteArrTwo(SingleMemberByteArrTwoClass.class);
        checkSingleMemberShortArrTwo(SingleMemberShortArrTwoClass.class);
        checkSingleMemberIntArrTwo(SingleMemberIntArrTwoClass.class);
        checkSingleMemberLongArrTwo(SingleMemberLongArrTwoClass.class);
        checkSingleMemberCharArrTwo(SingleMemberCharArrTwoClass.class);
        checkSingleMemberFloatArrTwo(SingleMemberFloatArrTwoClass.class);
        checkSingleMemberDoubleArrTwo(SingleMemberDoubleArrTwoClass.class);
        checkSingleMemberBooleanArrTwo(SingleMemberBooleanArrTwoClass.class);
        checkSingleMemberStringArrTwo(SingleMemberStringArrTwoClass.class);
        checkSingleMemberClassArrTwo(SingleMemberClassArrTwoClass.class);
        checkSingleMemberEnumArrTwo(SingleMemberEnumArrTwoClass.class);

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CLASS
        checkSingleMemberByteArrOvrdDef(SingleMemberByteArrOvrdDefClass.class);
        checkSingleMemberShortArrOvrdDef(SingleMemberShortArrOvrdDefClass.class);
        checkSingleMemberIntArrOvrdDef(SingleMemberIntArrOvrdDefClass.class);
        checkSingleMemberLongArrOvrdDef(SingleMemberLongArrOvrdDefClass.class);
        checkSingleMemberCharArrOvrdDef(SingleMemberCharArrOvrdDefClass.class);
        checkSingleMemberFloatArrOvrdDef(SingleMemberFloatArrOvrdDefClass.class);
        checkSingleMemberDoubleArrOvrdDef(SingleMemberDoubleArrOvrdDefClass.class);
        checkSingleMemberBooleanArrOvrdDef(SingleMemberBooleanArrOvrdDefClass.class);
        checkSingleMemberStringArrOvrdDef(SingleMemberStringArrOvrdDefClass.class);
        checkSingleMemberClassArrOvrdDef(SingleMemberClassArrOvrdDefClass.class);
        checkSingleMemberEnumArrOvrdDef(SingleMemberEnumArrOvrdDefClass.class);

        // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CLASS
        checkSingleMemberByteArrAcceptDef(SingleMemberByteArrAcceptDefClass.class);
        checkSingleMemberShortArrAcceptDef(SingleMemberShortArrAcceptDefClass.class);
        checkSingleMemberIntArrAcceptDef(SingleMemberIntArrAcceptDefClass.class);
        checkSingleMemberLongArrAcceptDef(SingleMemberLongArrAcceptDefClass.class);
        checkSingleMemberCharArrAcceptDef(SingleMemberCharArrAcceptDefClass.class);
        checkSingleMemberFloatArrAcceptDef(SingleMemberFloatArrAcceptDefClass.class);
        checkSingleMemberDoubleArrAcceptDef(SingleMemberDoubleArrAcceptDefClass.class);
        checkSingleMemberBooleanArrAcceptDef(SingleMemberBooleanArrAcceptDefClass.class);
        checkSingleMemberStringArrAcceptDef(SingleMemberStringArrAcceptDefClass.class);
        checkSingleMemberClassArrAcceptDef(SingleMemberClassArrAcceptDefClass.class);
        checkSingleMemberEnumArrAcceptDef(SingleMemberEnumArrAcceptDefClass.class);

        // *** TESTS FOR EQUALS AND HASHCODE - POSITIVE

        // MULTIMEMBER SCALAR TYPES
        checkEquals(scalarTypesClass.class, UnitTest.class.getField("scalarTypesField"),
                    ScalarTypes.class);
        checkEquals(scalarTypesOverrideDefaultClass.class, UnitTest.class.getField("scalarTypesOverrideDefaultField"),
                    ScalarTypesWithDefault.class);
        checkEquals(scalarTypesAcceptDefaultClass.class, UnitTest.class.getField("scalarTypesAcceptDefaultField"),
                    ScalarTypesWithDefault.class);

        // MULTIMEMBER ARRAY TYPES
        checkEquals(emptyArrayTypesClass.class, UnitTest.class.getField("emptyArrayTypesField"),
                    ArrayTypes.class);
        checkEquals(singleElementArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"),
                    ArrayTypes.class);
        checkEquals(twoElementArrayTypesClass.class, UnitTest.class.getField("twoElementArrayTypesField"),
                    ArrayTypes.class);
        checkEquals(arrayTypesOverrideDefaultClass.class, UnitTest.class.getField("arrayTypesOverrideDefaultField"),
                    ArrayTypesWithDefault.class);
        checkEquals(arrayTypesAcceptDefaultClass.class, UnitTest.class.getField("arrayTypesAcceptDefaultField"),
                    ArrayTypesWithDefault.class);

        // MARKER TYPE
        checkEquals(markerClass.class, UnitTest.class.getField("markerField"),
                    Marker.class);

        // SINGLE-MEMBER SCALAR TYPES
        checkEquals(SingleMemberByteClass.class, UnitTest.class.getField("SingleMemberByteField"),
                    SingleMemberByte.class);
        checkEquals(SingleMemberShortClass.class, UnitTest.class.getField("SingleMemberShortField"),
                    SingleMemberShort.class);
        checkEquals(SingleMemberIntClass.class, UnitTest.class.getField("SingleMemberIntField"),
                    SingleMemberInt.class);
        checkEquals(SingleMemberLongClass.class, UnitTest.class.getField("SingleMemberLongField"),
                    SingleMemberLong.class);
        checkEquals(SingleMemberCharClass.class, UnitTest.class.getField("SingleMemberCharField"),
                    SingleMemberChar.class);
        checkEquals(SingleMemberFloatClass.class, UnitTest.class.getField("SingleMemberFloatField"),
                    SingleMemberFloat.class);
        checkEquals(SingleMemberDoubleClass.class, UnitTest.class.getField("SingleMemberDoubleField"),
                    SingleMemberDouble.class);
        checkEquals(SingleMemberBooleanClass.class, UnitTest.class.getField("SingleMemberBooleanField"),
                    SingleMemberBoolean.class);
        checkEquals(SingleMemberStringClass.class, UnitTest.class.getField("SingleMemberStringField"),
                    SingleMemberString.class);
        checkEquals(SingleMemberClassClass.class, UnitTest.class.getField("SingleMemberClassField"),
                    SingleMemberClass.class);
        checkEquals(SingleMemberEnumClass.class, UnitTest.class.getField("SingleMemberEnumField"),
                    SingleMemberEnum.class);

        // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE
        checkEquals(SingleMemberByteOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteOvrdDefField"),
                    SingleMemberByteWithDef.class);
        checkEquals(SingleMemberShortOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortOvrdDefField"),
                    SingleMemberShortWithDef.class);
        checkEquals(SingleMemberIntOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntOvrdDefField"),
                    SingleMemberIntWithDef.class);
        checkEquals(SingleMemberLongOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongOvrdDefField"),
                    SingleMemberLongWithDef.class);
        checkEquals(SingleMemberCharOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharOvrdDefField"),
                    SingleMemberCharWithDef.class);
--> --------------------

--> maximum size reached

--> --------------------