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);

checkEquals(SingleMemberFloatOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatOvrdDefField"),

SingleMemberFloatWithDef.class);

checkEquals(SingleMemberDoubleOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleOvrdDefField"),

SingleMemberDoubleWithDef.class);

checkEquals(SingleMemberBooleanOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanOvrdDefField"),

SingleMemberBooleanWithDef.class);

checkEquals(SingleMemberStringOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringOvrdDefField"),

SingleMemberStringWithDef.class);

checkEquals(SingleMemberClassOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassOvrdDefField"),

SingleMemberClassWithDef.class);

checkEquals(SingleMemberEnumOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumOvrdDefField"),

SingleMemberEnumWithDef.class);

// SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT

checkEquals(SingleMemberByteAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteAcceptDefField"),

SingleMemberByteWithDef.class);

checkEquals(SingleMemberShortAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortAcceptDefField"),

SingleMemberShortWithDef.class);

checkEquals(SingleMemberIntAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntAcceptDefField"),

SingleMemberIntWithDef.class);

checkEquals(SingleMemberLongAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongAcceptDefField"),

SingleMemberLongWithDef.class);

checkEquals(SingleMemberCharAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharAcceptDefField"),

SingleMemberCharWithDef.class);

checkEquals(SingleMemberFloatAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatAcceptDefField"),

SingleMemberFloatWithDef.class);

checkEquals(SingleMemberDoubleAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleAcceptDefField"),

SingleMemberDoubleWithDef.class);

checkEquals(SingleMemberBooleanAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanAcceptDefField"),

SingleMemberBooleanWithDef.class);

checkEquals(SingleMemberStringAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringAcceptDefField"),

SingleMemberStringWithDef.class);

checkEquals(SingleMemberClassAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassAcceptDefField"),

SingleMemberClassWithDef.class);

checkEquals(SingleMemberEnumAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumAcceptDefField"),

SingleMemberEnumWithDef.class);

// SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY)

checkEquals(SingleMemberByteArrEmptyClass.class, UnitTest.class.getField("SingleMemberByteArrEmptyField"),

SingleMemberByteArray.class);

checkEquals(SingleMemberShortArrEmptyClass.class, UnitTest.class.getField("SingleMemberShortArrEmptyField"),

SingleMemberShortArray.class);

checkEquals(SingleMemberIntArrEmptyClass.class, UnitTest.class.getField("SingleMemberIntArrEmptyField"),

SingleMemberIntArray.class);

checkEquals(SingleMemberLongArrEmptyClass.class, UnitTest.class.getField("SingleMemberLongArrEmptyField"),

SingleMemberLongArray.class);

checkEquals(SingleMemberCharArrEmptyClass.class, UnitTest.class.getField("SingleMemberCharArrEmptyField"),

SingleMemberCharArray.class);

checkEquals(SingleMemberFloatArrEmptyClass.class, UnitTest.class.getField("SingleMemberFloatArrEmptyField"),

SingleMemberFloatArray.class);

checkEquals(SingleMemberDoubleArrEmptyClass.class, UnitTest.class.getField("SingleMemberDoubleArrEmptyField"),

SingleMemberDoubleArray.class);

checkEquals(SingleMemberBooleanArrEmptyClass.class, UnitTest.class.getField("SingleMemberBooleanArrEmptyField"),

SingleMemberBooleanArray.class);

checkEquals(SingleMemberStringArrEmptyClass.class, UnitTest.class.getField("SingleMemberStringArrEmptyField"),

SingleMemberStringArray.class);

checkEquals(SingleMemberClassArrEmptyClass.class, UnitTest.class.getField("SingleMemberClassArrEmptyField"),

SingleMemberClassArray.class);

checkEquals(SingleMemberEnumArrEmptyClass.class, UnitTest.class.getField("SingleMemberEnumArrEmptyField"),

SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY)

checkEquals(SingleMemberByteArrOneClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"),

SingleMemberByteArray.class);

checkEquals(SingleMemberShortArrOneClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"),

SingleMemberShortArray.class);

checkEquals(SingleMemberIntArrOneClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"),

SingleMemberIntArray.class);

checkEquals(SingleMemberLongArrOneClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"),

SingleMemberLongArray.class);

checkEquals(SingleMemberCharArrOneClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"),

SingleMemberCharArray.class);

checkEquals(SingleMemberFloatArrOneClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"),

SingleMemberFloatArray.class);

checkEquals(SingleMemberDoubleArrOneClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"),

SingleMemberDoubleArray.class);

checkEquals(SingleMemberBooleanArrOneClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"),

SingleMemberBooleanArray.class);

checkEquals(SingleMemberStringArrOneClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"),

SingleMemberStringArray.class);

checkEquals(SingleMemberClassArrOneClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"),

SingleMemberClassArray.class);

checkEquals(SingleMemberEnumArrOneClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"),

SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY)

checkEquals(SingleMemberByteArrTwoClass.class, UnitTest.class.getField("SingleMemberByteArrTwoField"),

SingleMemberByteArray.class);

checkEquals(SingleMemberShortArrTwoClass.class, UnitTest.class.getField("SingleMemberShortArrTwoField"),

SingleMemberShortArray.class);

checkEquals(SingleMemberIntArrTwoClass.class, UnitTest.class.getField("SingleMemberIntArrTwoField"),

SingleMemberIntArray.class);

checkEquals(SingleMemberLongArrTwoClass.class, UnitTest.class.getField("SingleMemberLongArrTwoField"),

SingleMemberLongArray.class);

checkEquals(SingleMemberCharArrTwoClass.class, UnitTest.class.getField("SingleMemberCharArrTwoField"),

SingleMemberCharArray.class);

checkEquals(SingleMemberFloatArrTwoClass.class, UnitTest.class.getField("SingleMemberFloatArrTwoField"),

SingleMemberFloatArray.class);

checkEquals(SingleMemberDoubleArrTwoClass.class, UnitTest.class.getField("SingleMemberDoubleArrTwoField"),

SingleMemberDoubleArray.class);

checkEquals(SingleMemberBooleanArrTwoClass.class, UnitTest.class.getField("SingleMemberBooleanArrTwoField"),

SingleMemberBooleanArray.class);

checkEquals(SingleMemberStringArrTwoClass.class, UnitTest.class.getField("SingleMemberStringArrTwoField"),

SingleMemberStringArray.class);

checkEquals(SingleMemberClassArrTwoClass.class, UnitTest.class.getField("SingleMemberClassArrTwoField"),

SingleMemberClassArray.class);

checkEquals(SingleMemberEnumArrTwoClass.class, UnitTest.class.getField("SingleMemberEnumArrTwoField"),

SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)

checkEquals(SingleMemberByteArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteArrOvrdDefField"),

SingleMemberByteArrayDef.class);

checkEquals(SingleMemberShortArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortArrOvrdDefField"),

SingleMemberShortArrayDef.class);

checkEquals(SingleMemberIntArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntArrOvrdDefField"),

SingleMemberIntArrayDef.class);

checkEquals(SingleMemberLongArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongArrOvrdDefField"),

SingleMemberLongArrayDef.class);

checkEquals(SingleMemberCharArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharArrOvrdDefField"),

SingleMemberCharArrayDef.class);

checkEquals(SingleMemberFloatArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"),

SingleMemberFloatArrayDef.class);

checkEquals(SingleMemberDoubleArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"),

SingleMemberDoubleArrayDef.class);

checkEquals(SingleMemberBooleanArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"),

SingleMemberBooleanArrayDef.class);

checkEquals(SingleMemberStringArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringArrOvrdDefField"),

SingleMemberStringArrayDef.class);

checkEquals(SingleMemberClassArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassArrOvrdDefField"),

SingleMemberClassArrayDef.class);

checkEquals(SingleMemberEnumArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"),

SingleMemberEnumArrayDef.class);

// SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)

checkEquals(SingleMemberByteArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteArrAcceptDefField"),

SingleMemberByteArrayDef.class);

checkEquals(SingleMemberShortArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortArrAcceptDefField"),

SingleMemberShortArrayDef.class);

checkEquals(SingleMemberIntArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntArrAcceptDefField"),

SingleMemberIntArrayDef.class);

checkEquals(SingleMemberLongArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongArrAcceptDefField"),

SingleMemberLongArrayDef.class);

checkEquals(SingleMemberCharArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharArrAcceptDefField"),

SingleMemberCharArrayDef.class);

checkEquals(SingleMemberFloatArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"),

SingleMemberFloatArrayDef.class);

checkEquals(SingleMemberDoubleArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"),

SingleMemberDoubleArrayDef.class);

checkEquals(SingleMemberBooleanArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"),

SingleMemberBooleanArrayDef.class);

checkEquals(SingleMemberStringArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringArrAcceptDefField"),

SingleMemberStringArrayDef.class);

checkEquals(SingleMemberClassArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassArrAcceptDefField"),

SingleMemberClassArrayDef.class);

checkEquals(SingleMemberEnumArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"),

SingleMemberEnumArrayDef.class);

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

// MULTIMEMBER SCALAR TYPES

checkUnequals(scalarTypesOverrideDefaultClass.class, UnitTest.class.getField("scalarTypesAcceptDefaultField"),

ScalarTypesWithDefault.class);

checkUnequals(scalarTypesAcceptDefaultClass.class, UnitTest.class.getField("scalarTypesOverrideDefaultField"),

ScalarTypesWithDefault.class);

// MULTIMEMBER ARRAY TYPES

checkUnequals(emptyArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"),

ArrayTypes.class);

checkUnequals(singleElementArrayTypesClass.class, UnitTest.class.getField("twoElementArrayTypesField"),

ArrayTypes.class);

checkUnequals(twoElementArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"),

ArrayTypes.class);

checkUnequals(arrayTypesOverrideDefaultClass.class, UnitTest.class.getField("arrayTypesAcceptDefaultField"),

ArrayTypesWithDefault.class);

checkUnequals(arrayTypesAcceptDefaultClass.class, UnitTest.class.getField("arrayTypesOverrideDefaultField"),

ArrayTypesWithDefault.class);

// SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE

checkUnequals(SingleMemberByteOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteAcceptDefField"),

SingleMemberByteWithDef.class);

checkUnequals(SingleMemberShortOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortAcceptDefField"),

SingleMemberShortWithDef.class);

checkUnequals(SingleMemberIntOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntAcceptDefField"),

SingleMemberIntWithDef.class);

checkUnequals(SingleMemberLongOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongAcceptDefField"),

SingleMemberLongWithDef.class);

checkUnequals(SingleMemberCharOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharAcceptDefField"),

SingleMemberCharWithDef.class);

checkUnequals(SingleMemberFloatOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatAcceptDefField"),

SingleMemberFloatWithDef.class);

checkUnequals(SingleMemberDoubleOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleAcceptDefField"),

SingleMemberDoubleWithDef.class);

checkUnequals(SingleMemberBooleanOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanAcceptDefField"),

SingleMemberBooleanWithDef.class);

checkUnequals(SingleMemberStringOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringAcceptDefField"),

SingleMemberStringWithDef.class);

checkUnequals(SingleMemberClassOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassAcceptDefField"),

SingleMemberClassWithDef.class);

checkUnequals(SingleMemberEnumOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumAcceptDefField"),

SingleMemberEnumWithDef.class);

// SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT

checkUnequals(SingleMemberByteAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteOvrdDefField"),

SingleMemberByteWithDef.class);

checkUnequals(SingleMemberShortAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortOvrdDefField"),

SingleMemberShortWithDef.class);

checkUnequals(SingleMemberIntAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntOvrdDefField"),

SingleMemberIntWithDef.class);

checkUnequals(SingleMemberLongAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongOvrdDefField"),

SingleMemberLongWithDef.class);

checkUnequals(SingleMemberCharAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharOvrdDefField"),

SingleMemberCharWithDef.class);

checkUnequals(SingleMemberFloatAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatOvrdDefField"),

SingleMemberFloatWithDef.class);

checkUnequals(SingleMemberDoubleAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleOvrdDefField"),

SingleMemberDoubleWithDef.class);

checkUnequals(SingleMemberBooleanAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanOvrdDefField"),

SingleMemberBooleanWithDef.class);

checkUnequals(SingleMemberStringAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringOvrdDefField"),

SingleMemberStringWithDef.class);

checkUnequals(SingleMemberClassAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassOvrdDefField"),

SingleMemberClassWithDef.class);

checkUnequals(SingleMemberEnumAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumOvrdDefField"),

SingleMemberEnumWithDef.class);

// SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY)

checkUnequals(SingleMemberByteArrEmptyClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"),

SingleMemberByteArray.class);

checkUnequals(SingleMemberShortArrEmptyClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"),

SingleMemberShortArray.class);

checkUnequals(SingleMemberIntArrEmptyClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"),

SingleMemberIntArray.class);

checkUnequals(SingleMemberLongArrEmptyClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"),

SingleMemberLongArray.class);

checkUnequals(SingleMemberCharArrEmptyClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"),

SingleMemberCharArray.class);

checkUnequals(SingleMemberFloatArrEmptyClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"),

SingleMemberFloatArray.class);

checkUnequals(SingleMemberDoubleArrEmptyClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"),

SingleMemberDoubleArray.class);

checkUnequals(SingleMemberBooleanArrEmptyClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"),

SingleMemberBooleanArray.class);

checkUnequals(SingleMemberStringArrEmptyClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"),

SingleMemberStringArray.class);

checkUnequals(SingleMemberClassArrEmptyClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"),

SingleMemberClassArray.class);

checkUnequals(SingleMemberEnumArrEmptyClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"),

SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY)

checkUnequals(SingleMemberByteArrOneClass.class, UnitTest.class.getField("SingleMemberByteArrTwoField"),

SingleMemberByteArray.class);

checkUnequals(SingleMemberShortArrOneClass.class, UnitTest.class.getField("SingleMemberShortArrTwoField"),

SingleMemberShortArray.class);

checkUnequals(SingleMemberIntArrOneClass.class, UnitTest.class.getField("SingleMemberIntArrTwoField"),

SingleMemberIntArray.class);

checkUnequals(SingleMemberLongArrOneClass.class, UnitTest.class.getField("SingleMemberLongArrTwoField"),

SingleMemberLongArray.class);

checkUnequals(SingleMemberCharArrOneClass.class, UnitTest.class.getField("SingleMemberCharArrTwoField"),

SingleMemberCharArray.class);

checkUnequals(SingleMemberFloatArrOneClass.class, UnitTest.class.getField("SingleMemberFloatArrTwoField"),

SingleMemberFloatArray.class);

checkUnequals(SingleMemberDoubleArrOneClass.class, UnitTest.class.getField("SingleMemberDoubleArrTwoField"),

SingleMemberDoubleArray.class);

checkUnequals(SingleMemberBooleanArrOneClass.class, UnitTest.class.getField("SingleMemberBooleanArrTwoField"),

SingleMemberBooleanArray.class);

checkUnequals(SingleMemberStringArrOneClass.class, UnitTest.class.getField("SingleMemberStringArrTwoField"),

SingleMemberStringArray.class);

checkUnequals(SingleMemberClassArrOneClass.class, UnitTest.class.getField("SingleMemberClassArrTwoField"),

SingleMemberClassArray.class);

checkUnequals(SingleMemberEnumArrOneClass.class, UnitTest.class.getField("SingleMemberEnumArrTwoField"),

SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY)

checkUnequals(SingleMemberByteArrTwoClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"),

SingleMemberByteArray.class);

checkUnequals(SingleMemberShortArrTwoClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"),

SingleMemberShortArray.class);

checkUnequals(SingleMemberIntArrTwoClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"),

SingleMemberIntArray.class);

checkUnequals(SingleMemberLongArrTwoClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"),

SingleMemberLongArray.class);

checkUnequals(SingleMemberCharArrTwoClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"),

SingleMemberCharArray.class);

checkUnequals(SingleMemberFloatArrTwoClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"),

SingleMemberFloatArray.class);

checkUnequals(SingleMemberDoubleArrTwoClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"),

SingleMemberDoubleArray.class);

checkUnequals(SingleMemberBooleanArrTwoClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"),

SingleMemberBooleanArray.class);

checkUnequals(SingleMemberStringArrTwoClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"),

SingleMemberStringArray.class);

checkUnequals(SingleMemberClassArrTwoClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"),

SingleMemberClassArray.class);

checkUnequals(SingleMemberEnumArrTwoClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"),

SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)

checkUnequals(SingleMemberByteArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteArrAcceptDefField"),

SingleMemberByteArrayDef.class);

checkUnequals(SingleMemberShortArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortArrAcceptDefField"),

SingleMemberShortArrayDef.class);

checkUnequals(SingleMemberIntArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntArrAcceptDefField"),

SingleMemberIntArrayDef.class);

checkUnequals(SingleMemberLongArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongArrAcceptDefField"),

SingleMemberLongArrayDef.class);

checkUnequals(SingleMemberCharArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharArrAcceptDefField"),

SingleMemberCharArrayDef.class);

checkUnequals(SingleMemberFloatArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"),

SingleMemberFloatArrayDef.class);

checkUnequals(SingleMemberDoubleArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"),

SingleMemberDoubleArrayDef.class);

checkUnequals(SingleMemberBooleanArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"),

SingleMemberBooleanArrayDef.class);

checkUnequals(SingleMemberStringArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringArrAcceptDefField"),

SingleMemberStringArrayDef.class);

checkUnequals(SingleMemberClassArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassArrAcceptDefField"),

SingleMemberClassArrayDef.class);

checkUnequals(SingleMemberEnumArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"),

SingleMemberEnumArrayDef.class);

// SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)

checkUnequals(SingleMemberByteArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteArrOvrdDefField"),

SingleMemberByteArrayDef.class);

checkUnequals(SingleMemberShortArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortArrOvrdDefField"),

SingleMemberShortArrayDef.class);

checkUnequals(SingleMemberIntArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntArrOvrdDefField"),

SingleMemberIntArrayDef.class);

checkUnequals(SingleMemberLongArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongArrOvrdDefField"),

SingleMemberLongArrayDef.class);

checkUnequals(SingleMemberCharArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharArrOvrdDefField"),

SingleMemberCharArrayDef.class);

checkUnequals(SingleMemberFloatArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"),

SingleMemberFloatArrayDef.class);

checkUnequals(SingleMemberDoubleArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"),

SingleMemberDoubleArrayDef.class);

checkUnequals(SingleMemberBooleanArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"),

SingleMemberBooleanArrayDef.class);

checkUnequals(SingleMemberStringArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringArrOvrdDefField"),

SingleMemberStringArrayDef.class);

checkUnequals(SingleMemberClassArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassArrOvrdDefField"),

SingleMemberClassArrayDef.class);

checkUnequals(SingleMemberEnumArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"),

SingleMemberEnumArrayDef.class);

// *** TESTS FOR SERIALIZATION AND DESERIALIZATION

// MULTIMEMBER SCALAR TYPES

checkSerialization(scalarTypesClass.class, ScalarTypes.class);

checkSerialization(scalarTypesOverrideDefaultClass.class, ScalarTypesWithDefault.class);

checkSerialization(scalarTypesAcceptDefaultClass.class, ScalarTypesWithDefault.class);

// MULTIMEMBER ARRAY TYPES

checkSerialization(emptyArrayTypesClass.class, ArrayTypes.class);

checkSerialization(singleElementArrayTypesClass.class, ArrayTypes.class);

checkSerialization(twoElementArrayTypesClass.class, ArrayTypes.class);

checkSerialization(arrayTypesOverrideDefaultClass.class, ArrayTypesWithDefault.class);

checkSerialization(arrayTypesAcceptDefaultClass.class, ArrayTypesWithDefault.class);

// MARKER TYPE

checkSerialization(markerClass.class, Marker.class);

// SINGLE-MEMBER SCALAR TYPES

checkSerialization(SingleMemberByteClass.class, SingleMemberByte.class);

checkSerialization(SingleMemberShortClass.class, SingleMemberShort.class);

checkSerialization(SingleMemberIntClass.class, SingleMemberInt.class);

checkSerialization(SingleMemberLongClass.class, SingleMemberLong.class);

checkSerialization(SingleMemberCharClass.class, SingleMemberChar.class);

checkSerialization(SingleMemberFloatClass.class, SingleMemberFloat.class);

checkSerialization(SingleMemberDoubleClass.class, SingleMemberDouble.class);

checkSerialization(SingleMemberBooleanClass.class, SingleMemberBoolean.class);

checkSerialization(SingleMemberStringClass.class, SingleMemberString.class);

checkSerialization(SingleMemberClassClass.class, SingleMemberClass.class);

checkSerialization(SingleMemberEnumClass.class, SingleMemberEnum.class);

// SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE

checkSerialization(SingleMemberByteOvrdDefClass.class, SingleMemberByteWithDef.class);

checkSerialization(SingleMemberShortOvrdDefClass.class, SingleMemberShortWithDef.class);

checkSerialization(SingleMemberIntOvrdDefClass.class, SingleMemberIntWithDef.class);

checkSerialization(SingleMemberLongOvrdDefClass.class, SingleMemberLongWithDef.class);

checkSerialization(SingleMemberCharOvrdDefClass.class, SingleMemberCharWithDef.class);

checkSerialization(SingleMemberFloatOvrdDefClass.class, SingleMemberFloatWithDef.class);

checkSerialization(SingleMemberDoubleOvrdDefClass.class, SingleMemberDoubleWithDef.class);

checkSerialization(SingleMemberBooleanOvrdDefClass.class, SingleMemberBooleanWithDef.class);

checkSerialization(SingleMemberStringOvrdDefClass.class, SingleMemberStringWithDef.class);

checkSerialization(SingleMemberClassOvrdDefClass.class, SingleMemberClassWithDef.class);

checkSerialization(SingleMemberEnumOvrdDefClass.class, SingleMemberEnumWithDef.class);

// SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT

checkSerialization(SingleMemberByteAcceptDefClass.class, SingleMemberByteWithDef.class);

checkSerialization(SingleMemberShortAcceptDefClass.class, SingleMemberShortWithDef.class);

checkSerialization(SingleMemberIntAcceptDefClass.class, SingleMemberIntWithDef.class);

checkSerialization(SingleMemberLongAcceptDefClass.class, SingleMemberLongWithDef.class);

checkSerialization(SingleMemberCharAcceptDefClass.class, SingleMemberCharWithDef.class);

checkSerialization(SingleMemberFloatAcceptDefClass.class, SingleMemberFloatWithDef.class);

checkSerialization(SingleMemberDoubleAcceptDefClass.class, SingleMemberDoubleWithDef.class);

checkSerialization(SingleMemberBooleanAcceptDefClass.class, SingleMemberBooleanWithDef.class);

checkSerialization(SingleMemberStringAcceptDefClass.class, SingleMemberStringWithDef.class);

checkSerialization(SingleMemberClassAcceptDefClass.class, SingleMemberClassWithDef.class);

checkSerialization(SingleMemberEnumAcceptDefClass.class, SingleMemberEnumWithDef.class);

// SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY)

checkSerialization(SingleMemberByteArrEmptyClass.class, SingleMemberByteArray.class);

checkSerialization(SingleMemberShortArrEmptyClass.class, SingleMemberShortArray.class);

checkSerialization(SingleMemberIntArrEmptyClass.class, SingleMemberIntArray.class);

checkSerialization(SingleMemberLongArrEmptyClass.class, SingleMemberLongArray.class);

checkSerialization(SingleMemberCharArrEmptyClass.class, SingleMemberCharArray.class);

checkSerialization(SingleMemberFloatArrEmptyClass.class, SingleMemberFloatArray.class);

checkSerialization(SingleMemberDoubleArrEmptyClass.class, SingleMemberDoubleArray.class);

checkSerialization(SingleMemberBooleanArrEmptyClass.class, SingleMemberBooleanArray.class);

checkSerialization(SingleMemberStringArrEmptyClass.class, SingleMemberStringArray.class);

checkSerialization(SingleMemberClassArrEmptyClass.class, SingleMemberClassArray.class);

checkSerialization(SingleMemberEnumArrEmptyClass.class, SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY)

checkSerialization(SingleMemberByteArrOneClass.class, SingleMemberByteArray.class);

checkSerialization(SingleMemberShortArrOneClass.class, SingleMemberShortArray.class);

checkSerialization(SingleMemberIntArrOneClass.class, SingleMemberIntArray.class);

checkSerialization(SingleMemberLongArrOneClass.class, SingleMemberLongArray.class);

checkSerialization(SingleMemberCharArrOneClass.class, SingleMemberCharArray.class);

checkSerialization(SingleMemberFloatArrOneClass.class, SingleMemberFloatArray.class);

checkSerialization(SingleMemberDoubleArrOneClass.class, SingleMemberDoubleArray.class);

checkSerialization(SingleMemberBooleanArrOneClass.class, SingleMemberBooleanArray.class);

checkSerialization(SingleMemberStringArrOneClass.class, SingleMemberStringArray.class);

checkSerialization(SingleMemberClassArrOneClass.class, SingleMemberClassArray.class);

checkSerialization(SingleMemberEnumArrOneClass.class, SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY)

checkSerialization(SingleMemberByteArrTwoClass.class, SingleMemberByteArray.class);

checkSerialization(SingleMemberShortArrTwoClass.class, SingleMemberShortArray.class);

checkSerialization(SingleMemberIntArrTwoClass.class, SingleMemberIntArray.class);

checkSerialization(SingleMemberLongArrTwoClass.class, SingleMemberLongArray.class);

checkSerialization(SingleMemberCharArrTwoClass.class, SingleMemberCharArray.class);

checkSerialization(SingleMemberFloatArrTwoClass.class, SingleMemberFloatArray.class);

checkSerialization(SingleMemberDoubleArrTwoClass.class, SingleMemberDoubleArray.class);

checkSerialization(SingleMemberBooleanArrTwoClass.class, SingleMemberBooleanArray.class);

checkSerialization(SingleMemberStringArrTwoClass.class, SingleMemberStringArray.class);

checkSerialization(SingleMemberClassArrTwoClass.class, SingleMemberClassArray.class);

checkSerialization(SingleMemberEnumArrTwoClass.class, SingleMemberEnumArray.class);

// SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)

checkSerialization(SingleMemberByteArrOvrdDefClass.class, SingleMemberByteArrayDef.class);

checkSerialization(SingleMemberShortArrOvrdDefClass.class, SingleMemberShortArrayDef.class);

checkSerialization(SingleMemberIntArrOvrdDefClass.class, SingleMemberIntArrayDef.class);

checkSerialization(SingleMemberLongArrOvrdDefClass.class, SingleMemberLongArrayDef.class);

checkSerialization(SingleMemberCharArrOvrdDefClass.class, SingleMemberCharArrayDef.class);

checkSerialization(SingleMemberFloatArrOvrdDefClass.class, SingleMemberFloatArrayDef.class);

checkSerialization(SingleMemberDoubleArrOvrdDefClass.class, SingleMemberDoubleArrayDef.class);

checkSerialization(SingleMemberBooleanArrOvrdDefClass.class, SingleMemberBooleanArrayDef.class);

checkSerialization(SingleMemberStringArrOvrdDefClass.class, SingleMemberStringArrayDef.class);

checkSerialization(SingleMemberClassArrOvrdDefClass.class, SingleMemberClassArrayDef.class);

checkSerialization(SingleMemberEnumArrOvrdDefClass.class, SingleMemberEnumArrayDef.class);

// SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)

checkSerialization(SingleMemberByteArrAcceptDefClass.class, SingleMemberByteArrayDef.class);

checkSerialization(SingleMemberShortArrAcceptDefClass.class, SingleMemberShortArrayDef.class);

checkSerialization(SingleMemberIntArrAcceptDefClass.class, SingleMemberIntArrayDef.class);

checkSerialization(SingleMemberLongArrAcceptDefClass.class, SingleMemberLongArrayDef.class);

checkSerialization(SingleMemberCharArrAcceptDefClass.class, SingleMemberCharArrayDef.class);

checkSerialization(SingleMemberFloatArrAcceptDefClass.class, SingleMemberFloatArrayDef.class);

checkSerialization(SingleMemberDoubleArrAcceptDefClass.class, SingleMemberDoubleArrayDef.class);

checkSerialization(SingleMemberBooleanArrAcceptDefClass.class, SingleMemberBooleanArrayDef.class);

checkSerialization(SingleMemberStringArrAcceptDefClass.class, SingleMemberStringArrayDef.class);

checkSerialization(SingleMemberClassArrAcceptDefClass.class, SingleMemberClassArrayDef.class);

checkSerialization(SingleMemberEnumArrAcceptDefClass.class, SingleMemberEnumArrayDef.class);

// *** TESTS FOR ANNOTATION INHERITANCE AND ENUMERATING DECLARED ANNOTATIONS

// Inheritance tests

checkInheritence(Grandpa.class, true, true);

checkInheritence(Dad.class, true, false);

checkInheritence(Son.class, true, true);

// Declared annotations tests

checkDeclaredAnnotations(Grandpa.class, true, true);

checkDeclaredAnnotations(Dad.class, false, false);

checkDeclaredAnnotations(Son.class, false, true);

// Generate summary

System.out.println("\n" + numTests + " tests completed");

if (failCount != 0)

throw new Exception("Failure count: " + failCount);

else

System.out.println("Success.");

}

static int failCount = 0;

private static void fail(String test) {

System.out.println("Failure: " + test);

failCount++;

}

// ANNOTATION-VERIFICATION METHODS

// Scalar multi-member

static void checkScalarTypes(AnnotatedElement e) {

try {

checkScalarTypes(e.getAnnotation(ScalarTypes.class), e);

} catch(Throwable t) {

fail("ScalarTypes " + e + ": " + t);

t.printStackTrace();

}

}

static void checkScalarTypes(ScalarTypes st, AnnotatedElement e) throws Exception {

numTests++;

if (!(st.b() == 1 &&

st.s() == 2 &&

st.i() == 3 &&

st.l() == 4L &&

st.c() == '5' &&

st.f() == 6.0f &&

st.d() == 7.0 &&

st.bool() == true &&

st.str().equals("custom") &&

st.cls() == Map.class &&

st.e() == Stooge.MOE &&

st.a().x() == 1 && st.a().y() == 2))

fail("ScalarTypes" + e);

}

static void checkScalarTypesOverrideDefault(AnnotatedElement e) {

try {

checkScalarTypesOverrideDefault(e.getAnnotation(ScalarTypesWithDefault.class), e);

} catch(Throwable t) {

fail("ScalarTypesOverrideDefaults" + e + ": " + t);

}

}

static void checkScalarTypesOverrideDefault(ScalarTypesWithDefault st, AnnotatedElement e) {

numTests++;

if (!(st.b() == 1 &&

st.s() == 2 &&

st.i() == 3 &&

st.l() == 4L &&

st.c() == '5' &&

st.f() == 6.0f &&

st.d() == 7.0 &&

st.bool() == true &&

st.str().equals("custom") &&

st.cls() == Map.class &&

st.e() == Stooge.MOE))

fail("ScalarTypesOverrideDefaults" + e);

}

static void checkScalarTypesAcceptDefault(AnnotatedElement e) {

try {

checkScalarTypesAcceptDefault(e.getAnnotation(ScalarTypesWithDefault.class), e);

} catch(Throwable t) {

fail("ScalarTypesAcceptDefaults" + e + ": " + t);

}

}

static void checkScalarTypesAcceptDefault(ScalarTypesWithDefault st, AnnotatedElement e) {

numTests++;

if (!(st.b() == 11 &&

st.s() == 12 &&

st.i() == 13 &&

st.l() == 14L &&

st.c() == 'V' &&

st.f() == 16.0f &&

st.d() == 17.0 &&

st.bool() == false &&

st.str().equals("default") &&

st.cls() == Class.class &&

st.e() == Stooge.LARRY &&

st.a().x() == 11 && st.a().y() == 12))

fail("ScalarTypesAcceptDefaults" + e);

}

// Array multi-member

static void checkArrayTypes0(AnnotatedElement e) {

try {

checkArrayTypes0(e.getAnnotation(ArrayTypes.class), e);

} catch(Throwable t) {

fail("ArrayTypes(Empty)" + e + ": " + t);

}

}

static void checkArrayTypes0(ArrayTypes at, AnnotatedElement e) {

numTests++;

if (!(at.b().length == 0 &&

at.s().length == 0 &&

at.i().length == 0 &&

at.l().length == 0 &&

at.c().length == 0 &&

at.f().length == 0 &&

at.d().length == 0 &&

at.bool().length == 0 &&

at.str().length == 0 &&

at.cls().length == 0 &&

at.e().length == 0 &&

at.a().length == 0)) {

fail("ArrayTypes(Empty)" + e);

}

}

static void checkArrayTypes1(AnnotatedElement e) {

try {

checkArrayTypes1(e.getAnnotation(ArrayTypes.class), e);

} catch(Throwable t) {

fail("ArrayTypes(One element)" + e + ": " + t);

}

}

static void checkArrayTypes1(ArrayTypes at, AnnotatedElement e) {

numTests++;

if (!(at.b()[0] == 1 &&

at.s()[0] == 2 &&

at.i()[0] == 3 &&

at.l()[0] == 4L &&

at.c()[0] == '5' &&

at.f()[0] == 6.0f &&

at.d()[0] == 7.0 &&

at.bool()[0] == true &&

at.str()[0].equals("custom") &&

at.cls()[0] == Map.class &&

at.e()[0] == Stooge.MOE &&

at.a()[0].x() == 1 && at.a()[0].y() == 2 &&

at.b().length==1 && at.s().length==1 && at.i().length==1 &&

at.l().length==1 && at.c().length==1 && at.d().length==1 &&

at.bool().length==1 && at.str().length==1 &&

at.cls().length==1 && at.cls().length==1 && at.a().length==1))

fail("ArrayTypes(One element)" + e);

}

static void checkArrayTypes2(AnnotatedElement e) {

try {

checkArrayTypes2(e.getAnnotation(ArrayTypes.class), e);

} catch(Throwable t) {

fail("ArrayTypes(Two element)" + e + ": " + t);

}

}

static void checkArrayTypes2(ArrayTypes at, AnnotatedElement e) {

numTests++;

if (!(at.b()[0] == 1 && at.b()[1] == 2 &&

at.s()[0] == 2 && at.s()[1] == 3 &&

at.i()[0] == 3 && at.i()[1] == 4 &&

at.l()[0] == 4L && at.l()[1] == 5L &&

at.c()[0] == '5' && at.c()[1] == '6' &&

at.f()[0] == 6.0f && at.f()[1] == 7.0f &&

at.d()[0] == 7.0 && at.d()[1] == 8.0 &&

at.bool()[0] == true && at.bool()[1] == false &&

at.str()[0].equals("custom") && at.str()[1].equals("paint") &&

at.cls()[0] == Map.class && at.cls()[1] == Set.class &&

at.e()[0] == Stooge.MOE && at.e()[1] == Stooge.CURLY &&

at.a()[0].x() == 1 && at.a()[0].y() == 2 && at.a()[1].x() == 3 && at.a()[1].y() == 4 &&

at.b().length==2 && at.s().length==2 && at.i().length==2 &&

at.l().length==2 && at.c().length==2 && at.d().length==2 &&

at.bool().length==2 && at.str().length==2 &&

at.cls().length==2 && at.cls().length==2 && at.a().length==2))

fail("ArrayTypes(Two element)" + e);

}

static void checkArrayTypesOverrideDefault(AnnotatedElement e) {

try {

checkArrayTypesOverrideDefault(e.getAnnotation(ArrayTypesWithDefault.class), e);

} catch(Throwable t) {

fail("ArrayTypesOverrideDefault" + e + ": " + t);

}

}

static void checkArrayTypesOverrideDefault(ArrayTypesWithDefault at, AnnotatedElement e) {

numTests++;

if (!(at.b()[0] == 1 &&

at.s()[0] == 2 &&

at.i()[0] == 3 &&

at.l()[0] == 4L &&

at.c()[0] == '5' &&

at.f()[0] == 6.0f &&

at.d()[0] == 7.0 &&

at.bool()[0] == true &&

at.str()[0].equals("custom") &&

at.cls()[0] == Map.class &&

at.e()[0] == Stooge.MOE &&

at.a()[0].x() == 1 && at.a()[0].y() == 2 &&

at.b().length==1 && at.s().length==1 && at.i().length==1 &&

at.l().length==1 && at.c().length==1 && at.d().length==1 &&

at.bool().length==1 && at.str().length==1 &&

at.cls().length==1 && at.cls().length==1))

fail("ArrayTypesOverrideDefault" + e);

}

static void checkArrayTypesAcceptDefault(AnnotatedElement e) {

try {

checkArrayTypesAcceptDefault(e.getAnnotation(ArrayTypesWithDefault.class), e);

} catch(Throwable t) {

fail("ArrayTypesAcceptDefault" + e + ": " + t);

}

}

static void checkArrayTypesAcceptDefault(ArrayTypesWithDefault at, AnnotatedElement e) {

numTests++;

if (!(at.b()[0] == 11 &&

at.s()[0] == 12 &&

at.i()[0] == 13 &&

at.l()[0] == 14L &&

at.c()[0] == 'V' &&

at.f()[0] == 16.0f &&

at.d()[0] == 17.0 &&

at.bool()[0] == false &&

at.str()[0].equals("default") &&

at.cls()[0] == Class.class &&

at.e()[0] == Stooge.LARRY &&

at.a()[0].x() == 11 && at.a()[0].y() == 12 &&

at.b().length==1 && at.s().length==1 && at.i().length==1 &&

at.l().length==1 && at.c().length==1 && at.d().length==1 &&

at.bool().length==1 && at.str().length==1 &&

at.cls().length==1 && at.cls().length==1))

fail("ArrayTypesAcceptDefault" + e);

}

// Scalar multi-member for parameters

static void checkScalarTypesParam(Method m) {

try {

checkScalarTypes((ScalarTypes) m.getParameterAnnotations()[0][0], m);

} catch(Throwable t) {

fail("ScalarTypes" + m + ": " + t);

}

}

static void checkScalarTypesOverrideDefaultParam(Method m) {

try {

checkScalarTypesOverrideDefault((ScalarTypesWithDefault) m.getParameterAnnotations()[0][0], m);

} catch(Throwable t) {

fail("ScalarTypesOverrideDefaults" + m + ": " + t);

}

}

static void checkScalarTypesAcceptDefaultParam(Method m) {

try {

checkScalarTypesAcceptDefault((ScalarTypesWithDefault) m.getParameterAnnotations()[0][0], m);

} catch(Throwable t) {

fail("ScalarTypesAcceptDefaults" + m + ": " + t);

}

}

// Array multi-member for parameters

static void checkArrayTypes0Param(Method m) {

try {

checkArrayTypes0((ArrayTypes) m.getParameterAnnotations()[0][0], m);

} catch(Throwable t) {

fail("ArrayTypes(Empty)" + m + ": " + t);

}

}

static void checkArrayTypes1Param(Method m) {

try {

checkArrayTypes1((ArrayTypes) m.getParameterAnnotations()[0][0], m);

} catch(Throwable t) {

fail("ArrayTypes(One Element)" + m + ": " + t);

}

}

static void checkArrayTypes2Param(Method m) {

try {

checkArrayTypes2((ArrayTypes) m.getParameterAnnotations()[0][0], m);

} catch(Throwable t) {

fail("ArrayTypes(Two Elements)" + m + ": " + t);

}

}

static void checkArrayTypesOverrideDefaultParam(Method m) {

try {

checkArrayTypesOverrideDefault((ArrayTypesWithDefault) m.getParameterAnnotations()[0][0], m);