|
Java example source code file (UnitTest.java)
The UnitTest.java Java example source code/* * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* * @test * @bug 4906359 4963461 4965058 4965039 4986770 * @summary Unit test for annotation reading * @author Josh Bloch */ import static java.lang.annotation.RetentionPolicy.RUNTIME; import java.lang.annotation.*; import java.util.*; import java.lang.reflect.*; import java.io.*; public class UnitTest { private static final Class[] X = new Class[0]; private static final Class[] Y = { int.class }; static int numTests = 0; public static void main(String[] args) throws Exception { // *** TESTS ON ANNOTATED METHODS *** // MULTIMEMBER SCALAR TYPES ON METHOD checkScalarTypes(UnitTest.class.getMethod("scalarTypesMethod", X)); checkScalarTypesOverrideDefault(UnitTest.class.getMethod("scalarTypesOverrideDefaultMethod", X)); checkScalarTypesAcceptDefault(UnitTest.class.getMethod("scalarTypesAcceptDefaultMethod", X)); // MULTIMEMBER ARRAY TYPES ON METHOD checkArrayTypes0(UnitTest.class.getMethod("emptyArrayTypesMethod", X)); checkArrayTypes1(UnitTest.class.getMethod("singleElementArrayTypesMethod", X)); checkArrayTypes2(UnitTest.class.getMethod("twoElementArrayTypesMethod", X)); checkArrayTypesAcceptDefault(UnitTest.class.getMethod("arrayTypesAcceptDefaultMethod", X)); checkArrayTypesOverrideDefault(UnitTest.class.getMethod("arrayTypesOverrideDefaultMethod", X)); // MARKER TYPE ON METHOD checkMarker(UnitTest.class.getMethod("markerMethod", X)); // SINGLE-MEMBER SCALAR TYPES ON METHOD checkSingleMemberByte(UnitTest.class.getMethod("SingleMemberByte", X)); checkSingleMemberShort(UnitTest.class.getMethod("SingleMemberShort", X)); checkSingleMemberInt(UnitTest.class.getMethod("SingleMemberInt", X)); checkSingleMemberLong(UnitTest.class.getMethod("SingleMemberLong", X)); checkSingleMemberChar(UnitTest.class.getMethod("SingleMemberChar", X)); checkSingleMemberFloat(UnitTest.class.getMethod("SingleMemberFloat", X)); checkSingleMemberDouble(UnitTest.class.getMethod("SingleMemberDouble", X)); checkSingleMemberBoolean(UnitTest.class.getMethod("SingleMemberBoolean", X)); checkSingleMemberString(UnitTest.class.getMethod("SingleMemberString", X)); checkSingleMemberClass(UnitTest.class.getMethod("SingleMemberClass", X)); checkSingleMemberEnum(UnitTest.class.getMethod("SingleMemberEnum", X)); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON METHOD checkSingleMemberByteOvrdDef(UnitTest.class.getMethod("SingleMemberByteOvrdDef", X)); checkSingleMemberShortOvrdDef(UnitTest.class.getMethod("SingleMemberShortOvrdDef", X)); checkSingleMemberIntOvrdDef(UnitTest.class.getMethod("SingleMemberIntOvrdDef", X)); checkSingleMemberLongOvrdDef(UnitTest.class.getMethod("SingleMemberLongOvrdDef", X)); checkSingleMemberCharOvrdDef(UnitTest.class.getMethod("SingleMemberCharOvrdDef", X)); checkSingleMemberFloatOvrdDef(UnitTest.class.getMethod("SingleMemberFloatOvrdDef", X)); checkSingleMemberDoubleOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleOvrdDef", X)); checkSingleMemberBooleanOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanOvrdDef", X)); checkSingleMemberStringOvrdDef(UnitTest.class.getMethod("SingleMemberStringOvrdDef", X)); checkSingleMemberClassOvrdDef(UnitTest.class.getMethod("SingleMemberClassOvrdDef", X)); checkSingleMemberEnumOvrdDef(UnitTest.class.getMethod("SingleMemberEnumOvrdDef", X)); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON METHOD checkSingleMemberByteAcceptDef(UnitTest.class.getMethod("SingleMemberByteAcceptDef", X)); checkSingleMemberShortAcceptDef(UnitTest.class.getMethod("SingleMemberShortAcceptDef", X)); checkSingleMemberIntAcceptDef(UnitTest.class.getMethod("SingleMemberIntAcceptDef", X)); checkSingleMemberLongAcceptDef(UnitTest.class.getMethod("SingleMemberLongAcceptDef", X)); checkSingleMemberCharAcceptDef(UnitTest.class.getMethod("SingleMemberCharAcceptDef", X)); checkSingleMemberFloatAcceptDef(UnitTest.class.getMethod("SingleMemberFloatAcceptDef", X)); checkSingleMemberDoubleAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleAcceptDef", X)); checkSingleMemberBooleanAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanAcceptDef", X)); checkSingleMemberStringAcceptDef(UnitTest.class.getMethod("SingleMemberStringAcceptDef", X)); checkSingleMemberClassAcceptDef(UnitTest.class.getMethod("SingleMemberClassAcceptDef", X)); checkSingleMemberEnumAcceptDef(UnitTest.class.getMethod("SingleMemberEnumAcceptDef", X)); // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON METHOD checkSingleMemberByteArrEmpty(UnitTest.class.getMethod("SingleMemberByteArrEmpty", X)); checkSingleMemberShortArrEmpty(UnitTest.class.getMethod("SingleMemberShortArrEmpty", X)); checkSingleMemberIntArrEmpty(UnitTest.class.getMethod("SingleMemberIntArrEmpty", X)); checkSingleMemberLongArrEmpty(UnitTest.class.getMethod("SingleMemberLongArrEmpty", X)); checkSingleMemberCharArrEmpty(UnitTest.class.getMethod("SingleMemberCharArrEmpty", X)); checkSingleMemberFloatArrEmpty(UnitTest.class.getMethod("SingleMemberFloatArrEmpty", X)); checkSingleMemberDoubleArrEmpty(UnitTest.class.getMethod("SingleMemberDoubleArrEmpty", X)); checkSingleMemberBooleanArrEmpty(UnitTest.class.getMethod("SingleMemberBooleanArrEmpty", X)); checkSingleMemberStringArrEmpty(UnitTest.class.getMethod("SingleMemberStringArrEmpty", X)); checkSingleMemberClassArrEmpty(UnitTest.class.getMethod("SingleMemberClassArrEmpty", X)); checkSingleMemberEnumArrEmpty(UnitTest.class.getMethod("SingleMemberEnumArrEmpty", X)); // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON METHOD checkSingleMemberByteArrOne(UnitTest.class.getMethod("SingleMemberByteArrOne", X)); checkSingleMemberShortArrOne(UnitTest.class.getMethod("SingleMemberShortArrOne", X)); checkSingleMemberIntArrOne(UnitTest.class.getMethod("SingleMemberIntArrOne", X)); checkSingleMemberLongArrOne(UnitTest.class.getMethod("SingleMemberLongArrOne", X)); checkSingleMemberCharArrOne(UnitTest.class.getMethod("SingleMemberCharArrOne", X)); checkSingleMemberFloatArrOne(UnitTest.class.getMethod("SingleMemberFloatArrOne", X)); checkSingleMemberDoubleArrOne(UnitTest.class.getMethod("SingleMemberDoubleArrOne", X)); checkSingleMemberBooleanArrOne(UnitTest.class.getMethod("SingleMemberBooleanArrOne", X)); checkSingleMemberStringArrOne(UnitTest.class.getMethod("SingleMemberStringArrOne", X)); checkSingleMemberClassArrOne(UnitTest.class.getMethod("SingleMemberClassArrOne", X)); checkSingleMemberEnumArrOne(UnitTest.class.getMethod("SingleMemberEnumArrOne", X)); // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON METHOD checkSingleMemberByteArrTwo(UnitTest.class.getMethod("SingleMemberByteArrTwo", X)); checkSingleMemberShortArrTwo(UnitTest.class.getMethod("SingleMemberShortArrTwo", X)); checkSingleMemberIntArrTwo(UnitTest.class.getMethod("SingleMemberIntArrTwo", X)); checkSingleMemberLongArrTwo(UnitTest.class.getMethod("SingleMemberLongArrTwo", X)); checkSingleMemberCharArrTwo(UnitTest.class.getMethod("SingleMemberCharArrTwo", X)); checkSingleMemberFloatArrTwo(UnitTest.class.getMethod("SingleMemberFloatArrTwo", X)); checkSingleMemberDoubleArrTwo(UnitTest.class.getMethod("SingleMemberDoubleArrTwo", X)); checkSingleMemberBooleanArrTwo(UnitTest.class.getMethod("SingleMemberBooleanArrTwo", X)); checkSingleMemberStringArrTwo(UnitTest.class.getMethod("SingleMemberStringArrTwo", X)); checkSingleMemberClassArrTwo(UnitTest.class.getMethod("SingleMemberClassArrTwo", X)); checkSingleMemberEnumArrTwo(UnitTest.class.getMethod("SingleMemberEnumArrTwo", X)); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON METHOD checkSingleMemberByteArrOvrdDef(UnitTest.class.getMethod("SingleMemberByteArrOvrdDef", X)); checkSingleMemberShortArrOvrdDef(UnitTest.class.getMethod("SingleMemberShortArrOvrdDef", X)); checkSingleMemberIntArrOvrdDef(UnitTest.class.getMethod("SingleMemberIntArrOvrdDef", X)); checkSingleMemberLongArrOvrdDef(UnitTest.class.getMethod("SingleMemberLongArrOvrdDef", X)); checkSingleMemberCharArrOvrdDef(UnitTest.class.getMethod("SingleMemberCharArrOvrdDef", X)); checkSingleMemberFloatArrOvrdDef(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDef", X)); checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDef", X)); checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDef", X)); checkSingleMemberStringArrOvrdDef(UnitTest.class.getMethod("SingleMemberStringArrOvrdDef", X)); checkSingleMemberClassArrOvrdDef(UnitTest.class.getMethod("SingleMemberClassArrOvrdDef", X)); checkSingleMemberEnumArrOvrdDef(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDef", X)); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON METHOD checkSingleMemberByteArrAcceptDef(UnitTest.class.getMethod("SingleMemberByteArrAcceptDef", X)); checkSingleMemberShortArrAcceptDef(UnitTest.class.getMethod("SingleMemberShortArrAcceptDef", X)); checkSingleMemberIntArrAcceptDef(UnitTest.class.getMethod("SingleMemberIntArrAcceptDef", X)); checkSingleMemberLongArrAcceptDef(UnitTest.class.getMethod("SingleMemberLongArrAcceptDef", X)); checkSingleMemberCharArrAcceptDef(UnitTest.class.getMethod("SingleMemberCharArrAcceptDef", X)); checkSingleMemberFloatArrAcceptDef(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDef", X)); checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDef", X)); checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDef", X)); checkSingleMemberStringArrAcceptDef(UnitTest.class.getMethod("SingleMemberStringArrAcceptDef", X)); checkSingleMemberClassArrAcceptDef(UnitTest.class.getMethod("SingleMemberClassArrAcceptDef", X)); checkSingleMemberEnumArrAcceptDef(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDef", X)); // *** TESTS ON ANNOTATED FIELDS *** // MULTIMEMBER SCALAR TYPES ON FIELD checkScalarTypes(UnitTest.class.getField("scalarTypesField")); checkScalarTypesAcceptDefault(UnitTest.class.getField("scalarTypesAcceptDefaultField")); checkScalarTypesOverrideDefault(UnitTest.class.getField("scalarTypesOverrideDefaultField")); // MULTIMEMBER ARRAY TYPES ON FIELD checkArrayTypes0(UnitTest.class.getField("emptyArrayTypesField")); checkArrayTypes1(UnitTest.class.getField("singleElementArrayTypesField")); checkArrayTypes2(UnitTest.class.getField("twoElementArrayTypesField")); checkArrayTypesAcceptDefault(UnitTest.class.getField("arrayTypesAcceptDefaultField")); checkArrayTypesOverrideDefault(UnitTest.class.getField("arrayTypesOverrideDefaultField")); // MARKER TYPE ON FIELD checkMarker(UnitTest.class.getField("markerField")); // SINGLE-MEMBER SCALAR TYPES ON FIELD checkSingleMemberByte(UnitTest.class.getField("SingleMemberByteField")); checkSingleMemberShort(UnitTest.class.getField("SingleMemberShortField")); checkSingleMemberInt(UnitTest.class.getField("SingleMemberIntField")); checkSingleMemberLong(UnitTest.class.getField("SingleMemberLongField")); checkSingleMemberChar(UnitTest.class.getField("SingleMemberCharField")); checkSingleMemberFloat(UnitTest.class.getField("SingleMemberFloatField")); checkSingleMemberDouble(UnitTest.class.getField("SingleMemberDoubleField")); checkSingleMemberBoolean(UnitTest.class.getField("SingleMemberBooleanField")); checkSingleMemberString(UnitTest.class.getField("SingleMemberStringField")); checkSingleMemberClass(UnitTest.class.getField("SingleMemberClassField")); checkSingleMemberEnum(UnitTest.class.getField("SingleMemberEnumField")); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON FIELD checkSingleMemberByteOvrdDef(UnitTest.class.getField("SingleMemberByteOvrdDefField")); checkSingleMemberShortOvrdDef(UnitTest.class.getField("SingleMemberShortOvrdDefField")); checkSingleMemberIntOvrdDef(UnitTest.class.getField("SingleMemberIntOvrdDefField")); checkSingleMemberLongOvrdDef(UnitTest.class.getField("SingleMemberLongOvrdDefField")); checkSingleMemberCharOvrdDef(UnitTest.class.getField("SingleMemberCharOvrdDefField")); checkSingleMemberFloatOvrdDef(UnitTest.class.getField("SingleMemberFloatOvrdDefField")); checkSingleMemberDoubleOvrdDef(UnitTest.class.getField("SingleMemberDoubleOvrdDefField")); checkSingleMemberBooleanOvrdDef(UnitTest.class.getField("SingleMemberBooleanOvrdDefField")); checkSingleMemberStringOvrdDef(UnitTest.class.getField("SingleMemberStringOvrdDefField")); checkSingleMemberClassOvrdDef(UnitTest.class.getField("SingleMemberClassOvrdDefField")); checkSingleMemberEnumOvrdDef(UnitTest.class.getField("SingleMemberEnumOvrdDefField")); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON FIELD checkSingleMemberByteAcceptDef(UnitTest.class.getField("SingleMemberByteAcceptDefField")); checkSingleMemberShortAcceptDef(UnitTest.class.getField("SingleMemberShortAcceptDefField")); checkSingleMemberIntAcceptDef(UnitTest.class.getField("SingleMemberIntAcceptDefField")); checkSingleMemberLongAcceptDef(UnitTest.class.getField("SingleMemberLongAcceptDefField")); checkSingleMemberCharAcceptDef(UnitTest.class.getField("SingleMemberCharAcceptDefField")); checkSingleMemberFloatAcceptDef(UnitTest.class.getField("SingleMemberFloatAcceptDefField")); checkSingleMemberDoubleAcceptDef(UnitTest.class.getField("SingleMemberDoubleAcceptDefField")); checkSingleMemberBooleanAcceptDef(UnitTest.class.getField("SingleMemberBooleanAcceptDefField")); checkSingleMemberStringAcceptDef(UnitTest.class.getField("SingleMemberStringAcceptDefField")); checkSingleMemberClassAcceptDef(UnitTest.class.getField("SingleMemberClassAcceptDefField")); checkSingleMemberEnumAcceptDef(UnitTest.class.getField("SingleMemberEnumAcceptDefField")); // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON FIELD checkSingleMemberByteArrEmpty(UnitTest.class.getField("SingleMemberByteArrEmptyField")); checkSingleMemberShortArrEmpty(UnitTest.class.getField("SingleMemberShortArrEmptyField")); checkSingleMemberIntArrEmpty(UnitTest.class.getField("SingleMemberIntArrEmptyField")); checkSingleMemberLongArrEmpty(UnitTest.class.getField("SingleMemberLongArrEmptyField")); checkSingleMemberCharArrEmpty(UnitTest.class.getField("SingleMemberCharArrEmptyField")); checkSingleMemberFloatArrEmpty(UnitTest.class.getField("SingleMemberFloatArrEmptyField")); checkSingleMemberDoubleArrEmpty(UnitTest.class.getField("SingleMemberDoubleArrEmptyField")); checkSingleMemberBooleanArrEmpty(UnitTest.class.getField("SingleMemberBooleanArrEmptyField")); checkSingleMemberStringArrEmpty(UnitTest.class.getField("SingleMemberStringArrEmptyField")); checkSingleMemberClassArrEmpty(UnitTest.class.getField("SingleMemberClassArrEmptyField")); checkSingleMemberEnumArrEmpty(UnitTest.class.getField("SingleMemberEnumArrEmptyField")); // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON FIELD checkSingleMemberByteArrOne(UnitTest.class.getField("SingleMemberByteArrOneField")); checkSingleMemberShortArrOne(UnitTest.class.getField("SingleMemberShortArrOneField")); checkSingleMemberIntArrOne(UnitTest.class.getField("SingleMemberIntArrOneField")); checkSingleMemberLongArrOne(UnitTest.class.getField("SingleMemberLongArrOneField")); checkSingleMemberCharArrOne(UnitTest.class.getField("SingleMemberCharArrOneField")); checkSingleMemberFloatArrOne(UnitTest.class.getField("SingleMemberFloatArrOneField")); checkSingleMemberDoubleArrOne(UnitTest.class.getField("SingleMemberDoubleArrOneField")); checkSingleMemberBooleanArrOne(UnitTest.class.getField("SingleMemberBooleanArrOneField")); checkSingleMemberStringArrOne(UnitTest.class.getField("SingleMemberStringArrOneField")); checkSingleMemberClassArrOne(UnitTest.class.getField("SingleMemberClassArrOneField")); checkSingleMemberEnumArrOne(UnitTest.class.getField("SingleMemberEnumArrOneField")); // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON FIELD checkSingleMemberByteArrTwo(UnitTest.class.getField("SingleMemberByteArrTwoField")); checkSingleMemberShortArrTwo(UnitTest.class.getField("SingleMemberShortArrTwoField")); checkSingleMemberIntArrTwo(UnitTest.class.getField("SingleMemberIntArrTwoField")); checkSingleMemberLongArrTwo(UnitTest.class.getField("SingleMemberLongArrTwoField")); checkSingleMemberCharArrTwo(UnitTest.class.getField("SingleMemberCharArrTwoField")); checkSingleMemberFloatArrTwo(UnitTest.class.getField("SingleMemberFloatArrTwoField")); checkSingleMemberDoubleArrTwo(UnitTest.class.getField("SingleMemberDoubleArrTwoField")); checkSingleMemberBooleanArrTwo(UnitTest.class.getField("SingleMemberBooleanArrTwoField")); checkSingleMemberStringArrTwo(UnitTest.class.getField("SingleMemberStringArrTwoField")); checkSingleMemberClassArrTwo(UnitTest.class.getField("SingleMemberClassArrTwoField")); checkSingleMemberEnumArrTwo(UnitTest.class.getField("SingleMemberEnumArrTwoField")); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON FIELD checkSingleMemberByteArrOvrdDef(UnitTest.class.getField("SingleMemberByteArrOvrdDefField")); checkSingleMemberShortArrOvrdDef(UnitTest.class.getField("SingleMemberShortArrOvrdDefField")); checkSingleMemberIntArrOvrdDef(UnitTest.class.getField("SingleMemberIntArrOvrdDefField")); checkSingleMemberLongArrOvrdDef(UnitTest.class.getField("SingleMemberLongArrOvrdDefField")); checkSingleMemberCharArrOvrdDef(UnitTest.class.getField("SingleMemberCharArrOvrdDefField")); checkSingleMemberFloatArrOvrdDef(UnitTest.class.getField("SingleMemberFloatArrOvrdDefField")); checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField")); checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField")); checkSingleMemberStringArrOvrdDef(UnitTest.class.getField("SingleMemberStringArrOvrdDefField")); checkSingleMemberClassArrOvrdDef(UnitTest.class.getField("SingleMemberClassArrOvrdDefField")); checkSingleMemberEnumArrOvrdDef(UnitTest.class.getField("SingleMemberEnumArrOvrdDefField")); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON FIELD checkSingleMemberByteArrAcceptDef(UnitTest.class.getField("SingleMemberByteArrAcceptDefField")); checkSingleMemberShortArrAcceptDef(UnitTest.class.getField("SingleMemberShortArrAcceptDefField")); checkSingleMemberIntArrAcceptDef(UnitTest.class.getField("SingleMemberIntArrAcceptDefField")); checkSingleMemberLongArrAcceptDef(UnitTest.class.getField("SingleMemberLongArrAcceptDefField")); checkSingleMemberCharArrAcceptDef(UnitTest.class.getField("SingleMemberCharArrAcceptDefField")); checkSingleMemberFloatArrAcceptDef(UnitTest.class.getField("SingleMemberFloatArrAcceptDefField")); checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField")); checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField")); checkSingleMemberStringArrAcceptDef(UnitTest.class.getField("SingleMemberStringArrAcceptDefField")); checkSingleMemberClassArrAcceptDef(UnitTest.class.getField("SingleMemberClassArrAcceptDefField")); checkSingleMemberEnumArrAcceptDef(UnitTest.class.getField("SingleMemberEnumArrAcceptDefField")); // *** TESTS ON ANNOTATED ENUM CONSTS *** // MULTIMEMBER SCALAR TYPES ON ENUM CONST checkScalarTypes(TestType.class.getField("scalarTypesField")); checkScalarTypesAcceptDefault(TestType.class.getField("scalarTypesAcceptDefaultField")); checkScalarTypesOverrideDefault(TestType.class.getField("scalarTypesOverrideDefaultField")); // MULTIMEMBER ARRAY TYPES ON ENUM CONST checkArrayTypes0(TestType.class.getField("emptyArrayTypesField")); checkArrayTypes1(TestType.class.getField("singleElementArrayTypesField")); checkArrayTypes2(TestType.class.getField("twoElementArrayTypesField")); checkArrayTypesAcceptDefault(TestType.class.getField("arrayTypesAcceptDefaultField")); checkArrayTypesOverrideDefault(TestType.class.getField("arrayTypesOverrideDefaultField")); // MARKER TYPE ON CLASS checkMarker(TestType.class.getField("marker")); // SINGLE-MEMBER SCALAR TYPES ON CLASS checkSingleMemberByte(TestType.class.getField("SingleMemberByte")); checkSingleMemberShort(TestType.class.getField("SingleMemberShort")); checkSingleMemberInt(TestType.class.getField("SingleMemberInt")); checkSingleMemberLong(TestType.class.getField("SingleMemberLong")); checkSingleMemberChar(TestType.class.getField("SingleMemberChar")); checkSingleMemberFloat(TestType.class.getField("SingleMemberFloat")); checkSingleMemberDouble(TestType.class.getField("SingleMemberDouble")); checkSingleMemberBoolean(TestType.class.getField("SingleMemberBoolean")); checkSingleMemberString(TestType.class.getField("SingleMemberString")); checkSingleMemberClass(TestType.class.getField("SingleMemberClass")); checkSingleMemberEnum(TestType.class.getField("SingleMemberEnum")); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS checkSingleMemberByteOvrdDef(TestType.class.getField("SingleMemberByteOvrdDef")); checkSingleMemberShortOvrdDef(TestType.class.getField("SingleMemberShortOvrdDef")); checkSingleMemberIntOvrdDef(TestType.class.getField("SingleMemberIntOvrdDef")); checkSingleMemberLongOvrdDef(TestType.class.getField("SingleMemberLongOvrdDef")); checkSingleMemberCharOvrdDef(TestType.class.getField("SingleMemberCharOvrdDef")); checkSingleMemberFloatOvrdDef(TestType.class.getField("SingleMemberFloatOvrdDef")); checkSingleMemberDoubleOvrdDef(TestType.class.getField("SingleMemberDoubleOvrdDef")); checkSingleMemberBooleanOvrdDef(TestType.class.getField("SingleMemberBooleanOvrdDef")); checkSingleMemberStringOvrdDef(TestType.class.getField("SingleMemberStringOvrdDef")); checkSingleMemberClassOvrdDef(TestType.class.getField("SingleMemberClassOvrdDef")); checkSingleMemberEnumOvrdDef(TestType.class.getField("SingleMemberEnumOvrdDef")); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS checkSingleMemberByteAcceptDef(TestType.class.getField("SingleMemberByteAcceptDef")); checkSingleMemberShortAcceptDef(TestType.class.getField("SingleMemberShortAcceptDef")); checkSingleMemberIntAcceptDef(TestType.class.getField("SingleMemberIntAcceptDef")); checkSingleMemberLongAcceptDef(TestType.class.getField("SingleMemberLongAcceptDef")); checkSingleMemberCharAcceptDef(TestType.class.getField("SingleMemberCharAcceptDef")); checkSingleMemberFloatAcceptDef(TestType.class.getField("SingleMemberFloatAcceptDef")); checkSingleMemberDoubleAcceptDef(TestType.class.getField("SingleMemberDoubleAcceptDef")); checkSingleMemberBooleanAcceptDef(TestType.class.getField("SingleMemberBooleanAcceptDef")); checkSingleMemberStringAcceptDef(TestType.class.getField("SingleMemberStringAcceptDef")); checkSingleMemberClassAcceptDef(TestType.class.getField("SingleMemberClassAcceptDef")); checkSingleMemberEnumAcceptDef(TestType.class.getField("SingleMemberEnumAcceptDef")); // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("EMPTY ARRAY) ON CLASS checkSingleMemberByteArrEmpty(TestType.class.getField("SingleMemberByteArrEmpty")); checkSingleMemberShortArrEmpty(TestType.class.getField("SingleMemberShortArrEmpty")); checkSingleMemberIntArrEmpty(TestType.class.getField("SingleMemberIntArrEmpty")); checkSingleMemberLongArrEmpty(TestType.class.getField("SingleMemberLongArrEmpty")); checkSingleMemberCharArrEmpty(TestType.class.getField("SingleMemberCharArrEmpty")); checkSingleMemberFloatArrEmpty(TestType.class.getField("SingleMemberFloatArrEmpty")); checkSingleMemberDoubleArrEmpty(TestType.class.getField("SingleMemberDoubleArrEmpty")); checkSingleMemberBooleanArrEmpty(TestType.class.getField("SingleMemberBooleanArrEmpty")); checkSingleMemberStringArrEmpty(TestType.class.getField("SingleMemberStringArrEmpty")); checkSingleMemberClassArrEmpty(TestType.class.getField("SingleMemberClassArrEmpty")); checkSingleMemberEnumArrEmpty(TestType.class.getField("SingleMemberEnumArrEmpty")); // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("ONE-ELEMENT ARRAY) ON CLASS checkSingleMemberByteArrOne(TestType.class.getField("SingleMemberByteArrOne")); checkSingleMemberShortArrOne(TestType.class.getField("SingleMemberShortArrOne")); checkSingleMemberIntArrOne(TestType.class.getField("SingleMemberIntArrOne")); checkSingleMemberLongArrOne(TestType.class.getField("SingleMemberLongArrOne")); checkSingleMemberCharArrOne(TestType.class.getField("SingleMemberCharArrOne")); checkSingleMemberFloatArrOne(TestType.class.getField("SingleMemberFloatArrOne")); checkSingleMemberDoubleArrOne(TestType.class.getField("SingleMemberDoubleArrOne")); checkSingleMemberBooleanArrOne(TestType.class.getField("SingleMemberBooleanArrOne")); checkSingleMemberStringArrOne(TestType.class.getField("SingleMemberStringArrOne")); checkSingleMemberClassArrOne(TestType.class.getField("SingleMemberClassArrOne")); checkSingleMemberEnumArrOne(TestType.class.getField("SingleMemberEnumArrOne")); // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("TWO-ELEMENT ARRAY) ON CLASS checkSingleMemberByteArrTwo(TestType.class.getField("SingleMemberByteArrTwo")); checkSingleMemberShortArrTwo(TestType.class.getField("SingleMemberShortArrTwo")); checkSingleMemberIntArrTwo(TestType.class.getField("SingleMemberIntArrTwo")); checkSingleMemberLongArrTwo(TestType.class.getField("SingleMemberLongArrTwo")); checkSingleMemberCharArrTwo(TestType.class.getField("SingleMemberCharArrTwo")); checkSingleMemberFloatArrTwo(TestType.class.getField("SingleMemberFloatArrTwo")); checkSingleMemberDoubleArrTwo(TestType.class.getField("SingleMemberDoubleArrTwo")); checkSingleMemberBooleanArrTwo(TestType.class.getField("SingleMemberBooleanArrTwo")); checkSingleMemberStringArrTwo(TestType.class.getField("SingleMemberStringArrTwo")); checkSingleMemberClassArrTwo(TestType.class.getField("SingleMemberClassArrTwo")); checkSingleMemberEnumArrTwo(TestType.class.getField("SingleMemberEnumArrTwo")); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("OVERRIDE)ON CLASS checkSingleMemberByteArrOvrdDef(TestType.class.getField("SingleMemberByteArrOvrdDef")); checkSingleMemberShortArrOvrdDef(TestType.class.getField("SingleMemberShortArrOvrdDef")); checkSingleMemberIntArrOvrdDef(TestType.class.getField("SingleMemberIntArrOvrdDef")); checkSingleMemberLongArrOvrdDef(TestType.class.getField("SingleMemberLongArrOvrdDef")); checkSingleMemberCharArrOvrdDef(TestType.class.getField("SingleMemberCharArrOvrdDef")); checkSingleMemberFloatArrOvrdDef(TestType.class.getField("SingleMemberFloatArrOvrdDef")); checkSingleMemberDoubleArrOvrdDef(TestType.class.getField("SingleMemberDoubleArrOvrdDef")); checkSingleMemberBooleanArrOvrdDef(TestType.class.getField("SingleMemberBooleanArrOvrdDef")); checkSingleMemberStringArrOvrdDef(TestType.class.getField("SingleMemberStringArrOvrdDef")); checkSingleMemberClassArrOvrdDef(TestType.class.getField("SingleMemberClassArrOvrdDef")); checkSingleMemberEnumArrOvrdDef(TestType.class.getField("SingleMemberEnumArrOvrdDef")); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("ACCEPT)ON CLASS checkSingleMemberByteArrAcceptDef(TestType.class.getField("SingleMemberByteArrAcceptDef")); checkSingleMemberShortArrAcceptDef(TestType.class.getField("SingleMemberShortArrAcceptDef")); checkSingleMemberIntArrAcceptDef(TestType.class.getField("SingleMemberIntArrAcceptDef")); checkSingleMemberLongArrAcceptDef(TestType.class.getField("SingleMemberLongArrAcceptDef")); checkSingleMemberCharArrAcceptDef(TestType.class.getField("SingleMemberCharArrAcceptDef")); checkSingleMemberFloatArrAcceptDef(TestType.class.getField("SingleMemberFloatArrAcceptDef")); checkSingleMemberDoubleArrAcceptDef(TestType.class.getField("SingleMemberDoubleArrAcceptDef")); checkSingleMemberBooleanArrAcceptDef(TestType.class.getField("SingleMemberBooleanArrAcceptDef")); checkSingleMemberStringArrAcceptDef(TestType.class.getField("SingleMemberStringArrAcceptDef")); checkSingleMemberClassArrAcceptDef(TestType.class.getField("SingleMemberClassArrAcceptDef")); checkSingleMemberEnumArrAcceptDef(TestType.class.getField("SingleMemberEnumArrAcceptDef")); // *** TESTS ON ANNOTATED CONSTRUCTORS *** // MULTIMEMBER SCALAR TYPES ON CONSTRUCTOR checkScalarTypes(UnitTest.class.getConstructor(new Class[]{Iterator.class})); checkScalarTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{Map.class})); checkScalarTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{Set.class})); // MULTIMEMBER ARRAY TYPES ON CONSTRUCTOR checkArrayTypes0(UnitTest.class.getConstructor(new Class[]{List.class})); checkArrayTypes1(UnitTest.class.getConstructor(new Class[]{Collection.class})); checkArrayTypes2(UnitTest.class.getConstructor(new Class[]{SortedSet.class})); checkArrayTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{SortedMap.class})); checkArrayTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{RandomAccess.class})); // MARKER TYPE ON CONSTRUCTOR checkMarker(UnitTest.class.getConstructor(new Class[] { })); // SINGLE-MEMBER SCALAR TYPES ON CONSTRUCTOR checkSingleMemberByte(UnitTest.class.getConstructor(new Class[] { byte.class })); checkSingleMemberShort(UnitTest.class.getConstructor(new Class[] { short.class })); checkSingleMemberInt(UnitTest.class.getConstructor(new Class[] { int.class })); checkSingleMemberLong(UnitTest.class.getConstructor(new Class[] { long.class })); checkSingleMemberChar(UnitTest.class.getConstructor(new Class[] { char.class })); checkSingleMemberFloat(UnitTest.class.getConstructor(new Class[] { float.class })); checkSingleMemberDouble(UnitTest.class.getConstructor(new Class[] { double.class })); checkSingleMemberBoolean(UnitTest.class.getConstructor(new Class[] { boolean.class })); checkSingleMemberString(UnitTest.class.getConstructor(new Class[] { String.class })); checkSingleMemberClass(UnitTest.class.getConstructor(new Class[] { Class.class })); checkSingleMemberEnum(UnitTest.class.getConstructor(new Class[] { Enum.class })); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CONSTRUCTOR checkSingleMemberByteOvrdDef(UnitTest.class.getConstructor(new Class[] { byte.class, Set.class })); checkSingleMemberShortOvrdDef(UnitTest.class.getConstructor(new Class[] { short.class, Set.class })); checkSingleMemberIntOvrdDef(UnitTest.class.getConstructor(new Class[] { int.class, Set.class })); checkSingleMemberLongOvrdDef(UnitTest.class.getConstructor(new Class[] { long.class, Set.class })); checkSingleMemberCharOvrdDef(UnitTest.class.getConstructor(new Class[] { char.class, Set.class })); checkSingleMemberFloatOvrdDef(UnitTest.class.getConstructor(new Class[] { float.class, Set.class })); checkSingleMemberDoubleOvrdDef(UnitTest.class.getConstructor(new Class[] { double.class, Set.class })); checkSingleMemberBooleanOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Set.class })); checkSingleMemberStringOvrdDef(UnitTest.class.getConstructor(new Class[] { String.class, Set.class })); checkSingleMemberClassOvrdDef(UnitTest.class.getConstructor(new Class[] { Class.class, Set.class })); checkSingleMemberEnumOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Set.class })); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CONSTRUCTOR checkSingleMemberByteAcceptDef(UnitTest.class.getConstructor(new Class[] { byte.class, Map.class })); checkSingleMemberShortAcceptDef(UnitTest.class.getConstructor(new Class[] { short.class, Map.class })); checkSingleMemberIntAcceptDef(UnitTest.class.getConstructor(new Class[] { int.class, Map.class })); checkSingleMemberLongAcceptDef(UnitTest.class.getConstructor(new Class[] { long.class, Map.class })); checkSingleMemberCharAcceptDef(UnitTest.class.getConstructor(new Class[] { char.class, Map.class })); checkSingleMemberFloatAcceptDef(UnitTest.class.getConstructor(new Class[] { float.class, Map.class })); checkSingleMemberDoubleAcceptDef(UnitTest.class.getConstructor(new Class[] { double.class, Map.class })); checkSingleMemberBooleanAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Map.class })); checkSingleMemberStringAcceptDef(UnitTest.class.getConstructor(new Class[] { String.class, Map.class })); checkSingleMemberClassAcceptDef(UnitTest.class.getConstructor(new Class[] { Class.class, Map.class })); checkSingleMemberEnumAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Map.class })); // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CONSTRUCTOR checkSingleMemberByteArrEmpty(UnitTest.class.getConstructor(new Class[] { byte[].class })); checkSingleMemberShortArrEmpty(UnitTest.class.getConstructor(new Class[] { short[].class })); checkSingleMemberIntArrEmpty(UnitTest.class.getConstructor(new Class[] { int[].class })); checkSingleMemberLongArrEmpty(UnitTest.class.getConstructor(new Class[] { long[].class })); checkSingleMemberCharArrEmpty(UnitTest.class.getConstructor(new Class[] { char[].class })); checkSingleMemberFloatArrEmpty(UnitTest.class.getConstructor(new Class[] { float[].class })); checkSingleMemberDoubleArrEmpty(UnitTest.class.getConstructor(new Class[] { double[].class })); checkSingleMemberBooleanArrEmpty(UnitTest.class.getConstructor(new Class[] { boolean[].class })); checkSingleMemberStringArrEmpty(UnitTest.class.getConstructor(new Class[] { String[].class })); checkSingleMemberClassArrEmpty(UnitTest.class.getConstructor(new Class[] { Class[].class })); checkSingleMemberEnumArrEmpty(UnitTest.class.getConstructor(new Class[] { Enum[].class })); // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CONSTRUCTOR checkSingleMemberByteArrOne(UnitTest.class.getConstructor(new Class[] { byte[].class, Set.class })); checkSingleMemberShortArrOne(UnitTest.class.getConstructor(new Class[] { short[].class, Set.class })); checkSingleMemberIntArrOne(UnitTest.class.getConstructor(new Class[] { int[].class, Set.class })); checkSingleMemberLongArrOne(UnitTest.class.getConstructor(new Class[] { long[].class, Set.class })); checkSingleMemberCharArrOne(UnitTest.class.getConstructor(new Class[] { char[].class, Set.class })); checkSingleMemberFloatArrOne(UnitTest.class.getConstructor(new Class[] { float[].class, Set.class })); checkSingleMemberDoubleArrOne(UnitTest.class.getConstructor(new Class[] { double[].class, Set.class })); checkSingleMemberBooleanArrOne(UnitTest.class.getConstructor(new Class[] { boolean[].class, Set.class })); checkSingleMemberStringArrOne(UnitTest.class.getConstructor(new Class[] { String[].class, Set.class })); checkSingleMemberClassArrOne(UnitTest.class.getConstructor(new Class[] { Class[].class, Set.class })); checkSingleMemberEnumArrOne(UnitTest.class.getConstructor(new Class[] { Enum[].class, Set.class })); // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CONSTRUCTOR checkSingleMemberByteArrTwo(UnitTest.class.getConstructor(new Class[] { byte[].class, Map.class })); checkSingleMemberShortArrTwo(UnitTest.class.getConstructor(new Class[] { short[].class, Map.class })); checkSingleMemberIntArrTwo(UnitTest.class.getConstructor(new Class[] { int[].class, Map.class })); checkSingleMemberLongArrTwo(UnitTest.class.getConstructor(new Class[] { long[].class, Map.class })); checkSingleMemberCharArrTwo(UnitTest.class.getConstructor(new Class[] { char[].class, Map.class })); checkSingleMemberFloatArrTwo(UnitTest.class.getConstructor(new Class[] { float[].class, Map.class })); checkSingleMemberDoubleArrTwo(UnitTest.class.getConstructor(new Class[] { double[].class, Map.class })); checkSingleMemberBooleanArrTwo(UnitTest.class.getConstructor(new Class[] { boolean[].class, Map.class })); checkSingleMemberStringArrTwo(UnitTest.class.getConstructor(new Class[] { String[].class, Map.class })); checkSingleMemberClassArrTwo(UnitTest.class.getConstructor(new Class[] { Class[].class, Map.class })); checkSingleMemberEnumArrTwo(UnitTest.class.getConstructor(new Class[] { Enum[].class, Map.class })); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CONSTRUCTOR checkSingleMemberByteArrOvrdDef(UnitTest.class.getConstructor(new Class[] { byte[].class, List.class })); checkSingleMemberShortArrOvrdDef(UnitTest.class.getConstructor(new Class[] { short[].class, List.class })); checkSingleMemberIntArrOvrdDef(UnitTest.class.getConstructor(new Class[] { int[].class, List.class })); checkSingleMemberLongArrOvrdDef(UnitTest.class.getConstructor(new Class[] { long[].class, List.class })); checkSingleMemberCharArrOvrdDef(UnitTest.class.getConstructor(new Class[] { char[].class, List.class })); checkSingleMemberFloatArrOvrdDef(UnitTest.class.getConstructor(new Class[] { float[].class, List.class })); checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getConstructor(new Class[] { double[].class, List.class })); checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, List.class })); checkSingleMemberStringArrOvrdDef(UnitTest.class.getConstructor(new Class[] { String[].class, List.class })); checkSingleMemberClassArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Class[].class, List.class })); checkSingleMemberEnumArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, List.class })); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CONSTRUCTOR checkSingleMemberByteArrAcceptDef(UnitTest.class.getConstructor(new Class[] { byte[].class, Collection.class })); checkSingleMemberShortArrAcceptDef(UnitTest.class.getConstructor(new Class[] { short[].class, Collection.class })); checkSingleMemberIntArrAcceptDef(UnitTest.class.getConstructor(new Class[] { int[].class, Collection.class })); checkSingleMemberLongArrAcceptDef(UnitTest.class.getConstructor(new Class[] { long[].class, Collection.class })); checkSingleMemberCharArrAcceptDef(UnitTest.class.getConstructor(new Class[] { char[].class, Collection.class })); checkSingleMemberFloatArrAcceptDef(UnitTest.class.getConstructor(new Class[] { float[].class, Collection.class })); checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getConstructor(new Class[] { double[].class, Collection.class })); checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, Collection.class })); checkSingleMemberStringArrAcceptDef(UnitTest.class.getConstructor(new Class[] { String[].class, Collection.class })); checkSingleMemberClassArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Class[].class, Collection.class })); checkSingleMemberEnumArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, Collection.class })); // *** TESTS ON ANNOTATED PARAMETERS *** // MULTIMEMBER SCALAR TYPES ON PARAM checkScalarTypesParam(UnitTest.class.getMethod("scalarTypesParam", Y)); checkScalarTypesOverrideDefaultParam(UnitTest.class.getMethod("scalarTypesOverrideDefaultParam", Y)); checkScalarTypesAcceptDefaultParam(UnitTest.class.getMethod("scalarTypesAcceptDefaultParam", Y)); // MULTIMEMBER ARRAY TYPES ON PARAM checkArrayTypes0Param(UnitTest.class.getMethod("emptyArrayTypesParam", Y)); checkArrayTypes1Param(UnitTest.class.getMethod("singleElementArrayTypesParam", Y)); checkArrayTypes2Param(UnitTest.class.getMethod("twoElementArrayTypesParam", Y)); checkArrayTypesAcceptDefaultParam(UnitTest.class.getMethod("arrayTypesAcceptDefaultParam", Y)); checkArrayTypesOverrideDefaultParam(UnitTest.class.getMethod("arrayTypesOverrideDefaultParam", Y)); // MARKER TYPE ON PARAMETER checkMarkerParam(UnitTest.class.getMethod("markerParam", Y)); // SINGLE-MEMBER SCALAR TYPES ON PARAMETER checkSingleMemberByteParam(UnitTest.class.getMethod("SingleMemberByteParam", Y)); checkSingleMemberShortParam(UnitTest.class.getMethod("SingleMemberShortParam", Y)); checkSingleMemberIntParam(UnitTest.class.getMethod("SingleMemberIntParam", Y)); checkSingleMemberLongParam(UnitTest.class.getMethod("SingleMemberLongParam", Y)); checkSingleMemberCharParam(UnitTest.class.getMethod("SingleMemberCharParam", Y)); checkSingleMemberFloatParam(UnitTest.class.getMethod("SingleMemberFloatParam", Y)); checkSingleMemberDoubleParam(UnitTest.class.getMethod("SingleMemberDoubleParam", Y)); checkSingleMemberBooleanParam(UnitTest.class.getMethod("SingleMemberBooleanParam", Y)); checkSingleMemberStringParam(UnitTest.class.getMethod("SingleMemberStringParam", Y)); checkSingleMemberClassParam(UnitTest.class.getMethod("SingleMemberClassParam", Y)); checkSingleMemberEnumParam(UnitTest.class.getMethod("SingleMemberEnumParam", Y)); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON PARAMETER checkSingleMemberByteOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteOvrdDefParam", Y)); checkSingleMemberShortOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortOvrdDefParam", Y)); checkSingleMemberIntOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntOvrdDefParam", Y)); checkSingleMemberLongOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongOvrdDefParam", Y)); checkSingleMemberCharOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharOvrdDefParam", Y)); checkSingleMemberFloatOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatOvrdDefParam", Y)); checkSingleMemberDoubleOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleOvrdDefParam", Y)); checkSingleMemberBooleanOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanOvrdDefParam", Y)); checkSingleMemberStringOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringOvrdDefParam", Y)); checkSingleMemberClassOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassOvrdDefParam", Y)); checkSingleMemberEnumOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumOvrdDefParam", Y)); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON PARAMETER checkSingleMemberByteAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteAcceptDefParam", Y)); checkSingleMemberShortAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortAcceptDefParam", Y)); checkSingleMemberIntAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntAcceptDefParam", Y)); checkSingleMemberLongAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongAcceptDefParam", Y)); checkSingleMemberCharAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharAcceptDefParam", Y)); checkSingleMemberFloatAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatAcceptDefParam", Y)); checkSingleMemberDoubleAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleAcceptDefParam", Y)); checkSingleMemberBooleanAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanAcceptDefParam", Y)); checkSingleMemberStringAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringAcceptDefParam", Y)); checkSingleMemberClassAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassAcceptDefParam", Y)); checkSingleMemberEnumAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumAcceptDefParam", Y)); // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("EMPTY ARRAY) ON PARAMETER checkSingleMemberByteArrEmptyParam(UnitTest.class.getMethod("SingleMemberByteArrEmptyParam", Y)); checkSingleMemberShortArrEmptyParam(UnitTest.class.getMethod("SingleMemberShortArrEmptyParam", Y)); checkSingleMemberIntArrEmptyParam(UnitTest.class.getMethod("SingleMemberIntArrEmptyParam", Y)); checkSingleMemberLongArrEmptyParam(UnitTest.class.getMethod("SingleMemberLongArrEmptyParam", Y)); checkSingleMemberCharArrEmptyParam(UnitTest.class.getMethod("SingleMemberCharArrEmptyParam", Y)); checkSingleMemberFloatArrEmptyParam(UnitTest.class.getMethod("SingleMemberFloatArrEmptyParam", Y)); checkSingleMemberDoubleArrEmptyParam(UnitTest.class.getMethod("SingleMemberDoubleArrEmptyParam", Y)); checkSingleMemberBooleanArrEmptyParam(UnitTest.class.getMethod("SingleMemberBooleanArrEmptyParam", Y)); checkSingleMemberStringArrEmptyParam(UnitTest.class.getMethod("SingleMemberStringArrEmptyParam", Y)); checkSingleMemberClassArrEmptyParam(UnitTest.class.getMethod("SingleMemberClassArrEmptyParam", Y)); checkSingleMemberEnumArrEmptyParam(UnitTest.class.getMethod("SingleMemberEnumArrEmptyParam", Y)); // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("ONE-ELEMENT ARRAY) ON PARAMETER checkSingleMemberByteArrOneParam(UnitTest.class.getMethod("SingleMemberByteArrOneParam", Y)); checkSingleMemberShortArrOneParam(UnitTest.class.getMethod("SingleMemberShortArrOneParam", Y)); checkSingleMemberIntArrOneParam(UnitTest.class.getMethod("SingleMemberIntArrOneParam", Y)); checkSingleMemberLongArrOneParam(UnitTest.class.getMethod("SingleMemberLongArrOneParam", Y)); checkSingleMemberCharArrOneParam(UnitTest.class.getMethod("SingleMemberCharArrOneParam", Y)); checkSingleMemberFloatArrOneParam(UnitTest.class.getMethod("SingleMemberFloatArrOneParam", Y)); checkSingleMemberDoubleArrOneParam(UnitTest.class.getMethod("SingleMemberDoubleArrOneParam", Y)); checkSingleMemberBooleanArrOneParam(UnitTest.class.getMethod("SingleMemberBooleanArrOneParam", Y)); checkSingleMemberStringArrOneParam(UnitTest.class.getMethod("SingleMemberStringArrOneParam", Y)); checkSingleMemberClassArrOneParam(UnitTest.class.getMethod("SingleMemberClassArrOneParam", Y)); checkSingleMemberEnumArrOneParam(UnitTest.class.getMethod("SingleMemberEnumArrOneParam", Y)); // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("TWO-ELEMENT ARRAY) ON PARAMETER checkSingleMemberByteArrTwoParam(UnitTest.class.getMethod("SingleMemberByteArrTwoParam", Y)); checkSingleMemberShortArrTwoParam(UnitTest.class.getMethod("SingleMemberShortArrTwoParam", Y)); checkSingleMemberIntArrTwoParam(UnitTest.class.getMethod("SingleMemberIntArrTwoParam", Y)); checkSingleMemberLongArrTwoParam(UnitTest.class.getMethod("SingleMemberLongArrTwoParam", Y)); checkSingleMemberCharArrTwoParam(UnitTest.class.getMethod("SingleMemberCharArrTwoParam", Y)); checkSingleMemberFloatArrTwoParam(UnitTest.class.getMethod("SingleMemberFloatArrTwoParam", Y)); checkSingleMemberDoubleArrTwoParam(UnitTest.class.getMethod("SingleMemberDoubleArrTwoParam", Y)); checkSingleMemberBooleanArrTwoParam(UnitTest.class.getMethod("SingleMemberBooleanArrTwoParam", Y)); checkSingleMemberStringArrTwoParam(UnitTest.class.getMethod("SingleMemberStringArrTwoParam", Y)); checkSingleMemberClassArrTwoParam(UnitTest.class.getMethod("SingleMemberClassArrTwoParam", Y)); checkSingleMemberEnumArrTwoParam(UnitTest.class.getMethod("SingleMemberEnumArrTwoParam", Y)); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("OVERRIDE)ON PARAMETER checkSingleMemberByteArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteArrOvrdDefParam", Y)); checkSingleMemberShortArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortArrOvrdDefParam", Y)); checkSingleMemberIntArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntArrOvrdDefParam", Y)); checkSingleMemberLongArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongArrOvrdDefParam", Y)); checkSingleMemberCharArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharArrOvrdDefParam", Y)); checkSingleMemberFloatArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDefParam", Y)); checkSingleMemberDoubleArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDefParam", Y)); checkSingleMemberBooleanArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDefParam", Y)); checkSingleMemberStringArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringArrOvrdDefParam", Y)); checkSingleMemberClassArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassArrOvrdDefParam", Y)); checkSingleMemberEnumArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDefParam", Y)); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("ACCEPT)ON PARAMETER checkSingleMemberByteArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteArrAcceptDefParam", Y)); checkSingleMemberShortArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortArrAcceptDefParam", Y)); checkSingleMemberIntArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntArrAcceptDefParam", Y)); checkSingleMemberLongArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongArrAcceptDefParam", Y)); checkSingleMemberCharArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharArrAcceptDefParam", Y)); checkSingleMemberFloatArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDefParam", Y)); checkSingleMemberDoubleArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDefParam", Y)); checkSingleMemberBooleanArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDefParam", Y)); checkSingleMemberStringArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringArrAcceptDefParam", Y)); checkSingleMemberClassArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassArrAcceptDefParam", Y)); checkSingleMemberEnumArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDefParam", Y)); // *** TESTS ON ANNOTATED CLASSES *** // MULTIMEMBER SCALAR TYPES ON CLASS checkScalarTypes(scalarTypesClass.class); checkScalarTypesOverrideDefault(scalarTypesOverrideDefaultClass.class); checkScalarTypesAcceptDefault(scalarTypesAcceptDefaultClass.class); // MULTIMEMBER ARRAY TYPES ON CLASS checkArrayTypes0(emptyArrayTypesClass.class); checkArrayTypes1(singleElementArrayTypesClass.class); checkArrayTypes2(twoElementArrayTypesClass.class); checkArrayTypesOverrideDefault(arrayTypesOverrideDefaultClass.class); checkArrayTypesAcceptDefault(arrayTypesAcceptDefaultClass.class); // MARKER TYPE ON CLASS checkMarker(markerClass.class); // SINGLE-MEMBER SCALAR TYPES ON CLASS checkSingleMemberByte(SingleMemberByteClass.class); checkSingleMemberShort(SingleMemberShortClass.class); checkSingleMemberInt(SingleMemberIntClass.class); checkSingleMemberLong(SingleMemberLongClass.class); checkSingleMemberChar(SingleMemberCharClass.class); checkSingleMemberFloat(SingleMemberFloatClass.class); checkSingleMemberDouble(SingleMemberDoubleClass.class); checkSingleMemberBoolean(SingleMemberBooleanClass.class); checkSingleMemberString(SingleMemberStringClass.class); checkSingleMemberClass(SingleMemberClassClass.class); checkSingleMemberEnum(SingleMemberEnumClass.class); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS checkSingleMemberByteOvrdDef(SingleMemberByteOvrdDefClass.class); checkSingleMemberShortOvrdDef(SingleMemberShortOvrdDefClass.class); checkSingleMemberIntOvrdDef(SingleMemberIntOvrdDefClass.class); checkSingleMemberLongOvrdDef(SingleMemberLongOvrdDefClass.class); checkSingleMemberCharOvrdDef(SingleMemberCharOvrdDefClass.class); checkSingleMemberFloatOvrdDef(SingleMemberFloatOvrdDefClass.class); checkSingleMemberDoubleOvrdDef(SingleMemberDoubleOvrdDefClass.class); checkSingleMemberBooleanOvrdDef(SingleMemberBooleanOvrdDefClass.class); checkSingleMemberStringOvrdDef(SingleMemberStringOvrdDefClass.class); checkSingleMemberClassOvrdDef(SingleMemberClassOvrdDefClass.class); checkSingleMemberEnumOvrdDef(SingleMemberEnumOvrdDefClass.class); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS checkSingleMemberByteAcceptDef(SingleMemberByteAcceptDefClass.class); checkSingleMemberShortAcceptDef(SingleMemberShortAcceptDefClass.class); checkSingleMemberIntAcceptDef(SingleMemberIntAcceptDefClass.class); checkSingleMemberLongAcceptDef(SingleMemberLongAcceptDefClass.class); checkSingleMemberCharAcceptDef(SingleMemberCharAcceptDefClass.class); checkSingleMemberFloatAcceptDef(SingleMemberFloatAcceptDefClass.class); checkSingleMemberDoubleAcceptDef(SingleMemberDoubleAcceptDefClass.class); checkSingleMemberBooleanAcceptDef(SingleMemberBooleanAcceptDefClass.class); checkSingleMemberStringAcceptDef(SingleMemberStringAcceptDefClass.class); checkSingleMemberClassAcceptDef(SingleMemberClassAcceptDefClass.class); checkSingleMemberEnumAcceptDef(SingleMemberEnumAcceptDefClass.class); // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CLASS checkSingleMemberByteArrEmpty(SingleMemberByteArrEmptyClass.class); checkSingleMemberShortArrEmpty(SingleMemberShortArrEmptyClass.class); checkSingleMemberIntArrEmpty(SingleMemberIntArrEmptyClass.class); checkSingleMemberLongArrEmpty(SingleMemberLongArrEmptyClass.class); checkSingleMemberCharArrEmpty(SingleMemberCharArrEmptyClass.class); checkSingleMemberFloatArrEmpty(SingleMemberFloatArrEmptyClass.class); checkSingleMemberDoubleArrEmpty(SingleMemberDoubleArrEmptyClass.class); checkSingleMemberBooleanArrEmpty(SingleMemberBooleanArrEmptyClass.class); checkSingleMemberStringArrEmpty(SingleMemberStringArrEmptyClass.class); checkSingleMemberClassArrEmpty(SingleMemberClassArrEmptyClass.class); checkSingleMemberEnumArrEmpty(SingleMemberEnumArrEmptyClass.class); // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CLASS checkSingleMemberByteArrOne(SingleMemberByteArrOneClass.class); checkSingleMemberShortArrOne(SingleMemberShortArrOneClass.class); checkSingleMemberIntArrOne(SingleMemberIntArrOneClass.class); checkSingleMemberLongArrOne(SingleMemberLongArrOneClass.class); checkSingleMemberCharArrOne(SingleMemberCharArrOneClass.class); checkSingleMemberFloatArrOne(SingleMemberFloatArrOneClass.class); checkSingleMemberDoubleArrOne(SingleMemberDoubleArrOneClass.class); checkSingleMemberBooleanArrOne(SingleMemberBooleanArrOneClass.class); checkSingleMemberStringArrOne(SingleMemberStringArrOneClass.class); checkSingleMemberClassArrOne(SingleMemberClassArrOneClass.class); checkSingleMemberEnumArrOne(SingleMemberEnumArrOneClass.class); // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CLASS checkSingleMemberByteArrTwo(SingleMemberByteArrTwoClass.class); checkSingleMemberShortArrTwo(SingleMemberShortArrTwoClass.class); checkSingleMemberIntArrTwo(SingleMemberIntArrTwoClass.class); checkSingleMemberLongArrTwo(SingleMemberLongArrTwoClass.class); checkSingleMemberCharArrTwo(SingleMemberCharArrTwoClass.class); checkSingleMemberFloatArrTwo(SingleMemberFloatArrTwoClass.class); checkSingleMemberDoubleArrTwo(SingleMemberDoubleArrTwoClass.class); checkSingleMemberBooleanArrTwo(SingleMemberBooleanArrTwoClass.class); checkSingleMemberStringArrTwo(SingleMemberStringArrTwoClass.class); checkSingleMemberClassArrTwo(SingleMemberClassArrTwoClass.class); checkSingleMemberEnumArrTwo(SingleMemberEnumArrTwoClass.class); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CLASS checkSingleMemberByteArrOvrdDef(SingleMemberByteArrOvrdDefClass.class); checkSingleMemberShortArrOvrdDef(SingleMemberShortArrOvrdDefClass.class); checkSingleMemberIntArrOvrdDef(SingleMemberIntArrOvrdDefClass.class); checkSingleMemberLongArrOvrdDef(SingleMemberLongArrOvrdDefClass.class); checkSingleMemberCharArrOvrdDef(SingleMemberCharArrOvrdDefClass.class); checkSingleMemberFloatArrOvrdDef(SingleMemberFloatArrOvrdDefClass.class); checkSingleMemberDoubleArrOvrdDef(SingleMemberDoubleArrOvrdDefClass.class); checkSingleMemberBooleanArrOvrdDef(SingleMemberBooleanArrOvrdDefClass.class); checkSingleMemberStringArrOvrdDef(SingleMemberStringArrOvrdDefClass.class); checkSingleMemberClassArrOvrdDef(SingleMemberClassArrOvrdDefClass.class); checkSingleMemberEnumArrOvrdDef(SingleMemberEnumArrOvrdDefClass.class); // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CLASS checkSingleMemberByteArrAcceptDef(SingleMemberByteArrAcceptDefClass.class); checkSingleMemberShortArrAcceptDef(SingleMemberShortArrAcceptDefClass.class); checkSingleMemberIntArrAcceptDef(SingleMemberIntArrAcceptDefClass.class); checkSingleMemberLongArrAcceptDef(SingleMemberLongArrAcceptDefClass.class); checkSingleMemberCharArrAcceptDef(SingleMemberCharArrAcceptDefClass.class); checkSingleMemberFloatArrAcceptDef(SingleMemberFloatArrAcceptDefClass.class); checkSingleMemberDoubleArrAcceptDef(SingleMemberDoubleArrAcceptDefClass.class); checkSingleMemberBooleanArrAcceptDef(SingleMemberBooleanArrAcceptDefClass.class); checkSingleMemberStringArrAcceptDef(SingleMemberStringArrAcceptDefClass.class); checkSingleMemberClassArrAcceptDef(SingleMemberClassArrAcceptDefClass.class); checkSingleMemberEnumArrAcceptDef(SingleMemberEnumArrAcceptDefClass.class); // *** TESTS FOR EQUALS AND HASHCODE - POSITIVE // MULTIMEMBER SCALAR TYPES checkEquals(scalarTypesClass.class, UnitTest.class.getField("scalarTypesField"), ScalarTypes.class); checkEquals(scalarTypesOverrideDefaultClass.class, UnitTest.class.getField("scalarTypesOverrideDefaultField"), ScalarTypesWithDefault.class); checkEquals(scalarTypesAcceptDefaultClass.class, UnitTest.class.getField("scalarTypesAcceptDefaultField"), ScalarTypesWithDefault.class); // MULTIMEMBER ARRAY TYPES checkEquals(emptyArrayTypesClass.class, UnitTest.class.getField("emptyArrayTypesField"), ArrayTypes.class); checkEquals(singleElementArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"), ArrayTypes.class); checkEquals(twoElementArrayTypesClass.class, UnitTest.class.getField("twoElementArrayTypesField"), ArrayTypes.class); checkEquals(arrayTypesOverrideDefaultClass.class, UnitTest.class.getField("arrayTypesOverrideDefaultField"), ArrayTypesWithDefault.class); checkEquals(arrayTypesAcceptDefaultClass.class, UnitTest.class.getField("arrayTypesAcceptDefaultField"), ArrayTypesWithDefault.class); // MARKER TYPE checkEquals(markerClass.class, UnitTest.class.getField("markerField"), Marker.class); // SINGLE-MEMBER SCALAR TYPES checkEquals(SingleMemberByteClass.class, UnitTest.class.getField("SingleMemberByteField"), SingleMemberByte.class); checkEquals(SingleMemberShortClass.class, UnitTest.class.getField("SingleMemberShortField"), SingleMemberShort.class); checkEquals(SingleMemberIntClass.class, UnitTest.class.getField("SingleMemberIntField"), SingleMemberInt.class); checkEquals(SingleMemberLongClass.class, UnitTest.class.getField("SingleMemberLongField"), SingleMemberLong.class); checkEquals(SingleMemberCharClass.class, UnitTest.class.getField("SingleMemberCharField"), SingleMemberChar.class); checkEquals(SingleMemberFloatClass.class, UnitTest.class.getField("SingleMemberFloatField"), SingleMemberFloat.class); checkEquals(SingleMemberDoubleClass.class, UnitTest.class.getField("SingleMemberDoubleField"), SingleMemberDouble.class); checkEquals(SingleMemberBooleanClass.class, UnitTest.class.getField("SingleMemberBooleanField"), SingleMemberBoolean.class); checkEquals(SingleMemberStringClass.class, UnitTest.class.getField("SingleMemberStringField"), SingleMemberString.class); checkEquals(SingleMemberClassClass.class, UnitTest.class.getField("SingleMemberClassField"), SingleMemberClass.class); checkEquals(SingleMemberEnumClass.class, UnitTest.class.getField("SingleMemberEnumField"), SingleMemberEnum.class); // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE checkEquals(SingleMemberByteOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteOvrdDefField"), SingleMemberByteWithDef.class); checkEquals(SingleMemberShortOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortOvrdDefField"), SingleMemberShortWithDef.class); checkEquals(SingleMemberIntOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntOvrdDefField"), SingleMemberIntWithDef.class); checkEquals(SingleMemberLongOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongOvrdDefField"), SingleMemberLongWithDef.class); checkEquals(SingleMemberCharOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharOvrdDefField"), SingleMemberCharWithDef.class); 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); } catch(Throwable t) { fail("ArrayTypesOverrideDefault" + m + ": " + t); } } static void checkArrayTypesAcceptDefaultParam(Method m) { try { checkArrayTypesAcceptDefault((ArrayTypesWithDefault) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("ArrayTypesAcceptDefault" + m + ": " + t); } } // marker type on parameter static void checkMarkerParam(Method m) { try { checkMarker((Marker) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("Marker" + m + ": " + t); } } // single-member scalar types on parameter static void checkSingleMemberByteParam(Method m) { try { checkSingleMemberByte((SingleMemberByte) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByte" + m + ": " + t); } } static void checkSingleMemberShortParam(Method m) { try { checkSingleMemberShort((SingleMemberShort) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShort" + m + ": " + t); } } static void checkSingleMemberIntParam(Method m) { try { checkSingleMemberInt((SingleMemberInt) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberInt" + m + ": " + t); } } static void checkSingleMemberLongParam(Method m) { try { checkSingleMemberLong((SingleMemberLong) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLong" + m + ": " + t); } } static void checkSingleMemberCharParam(Method m) { try { checkSingleMemberChar((SingleMemberChar) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberChar" + m + ": " + t); } } static void checkSingleMemberFloatParam(Method m) { try { checkSingleMemberFloat((SingleMemberFloat) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloat" + m + ": " + t); } } static void checkSingleMemberDoubleParam(Method m) { try { checkSingleMemberDouble((SingleMemberDouble) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDouble" + m + ": " + t); } } static void checkSingleMemberBooleanParam(Method m) { try { checkSingleMemberBoolean((SingleMemberBoolean) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBoolean" + m + ": " + t); } } static void checkSingleMemberStringParam(Method m) { try { checkSingleMemberString((SingleMemberString) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberString" + m + ": " + t); } } static void checkSingleMemberClassParam(Method m) { try { checkSingleMemberClass((SingleMemberClass) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClass" + m + ": " + t); } } static void checkSingleMemberEnumParam(Method m) { try { checkSingleMemberEnum((SingleMemberEnum) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnum" + m + ": " + t); } } // single-member scalar types with default-override on parameter static void checkSingleMemberByteOvrdDefParam(Method m) { try { checkSingleMemberByteOvrdDef((SingleMemberByteWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByteOvrdDef" + m + ": " + t); } } static void checkSingleMemberShortOvrdDefParam(Method m) { try { checkSingleMemberShortOvrdDef((SingleMemberShortWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShortOvrdDef" + m + ": " + t); } } static void checkSingleMemberIntOvrdDefParam(Method m) { try { checkSingleMemberIntOvrdDef((SingleMemberIntWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberIntOvrdDef" + m + ": " + t); } } static void checkSingleMemberLongOvrdDefParam(Method m) { try { checkSingleMemberLongOvrdDef((SingleMemberLongWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLongOvrdDef" + m + ": " + t); } } static void checkSingleMemberCharOvrdDefParam(Method m) { try { checkSingleMemberCharOvrdDef((SingleMemberCharWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberCharOvrdDef" + m + ": " + t); } } static void checkSingleMemberFloatOvrdDefParam(Method m) { try { checkSingleMemberFloatOvrdDef((SingleMemberFloatWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloatOvrdDef" + m + ": " + t); } } static void checkSingleMemberDoubleOvrdDefParam(Method m) { try { checkSingleMemberDoubleOvrdDef((SingleMemberDoubleWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDoubleOvrdDef" + m + ": " + t); } } static void checkSingleMemberBooleanOvrdDefParam(Method m) { try { checkSingleMemberBooleanOvrdDef((SingleMemberBooleanWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBooleanOvrdDef" + m + ": " + t); } } static void checkSingleMemberStringOvrdDefParam(Method m) { try { checkSingleMemberStringOvrdDef((SingleMemberStringWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberStringOvrdDef" + m + ": " + t); } } static void checkSingleMemberClassOvrdDefParam(Method m) { try { checkSingleMemberClassOvrdDef((SingleMemberClassWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClassOvrdDef" + m + ": " + t); } } static void checkSingleMemberEnumOvrdDefParam(Method m) { try { checkSingleMemberEnumOvrdDef((SingleMemberEnumWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnumOvrdDef" + m + ": " + t); } } // single-member scalar types with default-accept on PARAMETER static void checkSingleMemberByteAcceptDefParam(Method m) { try { checkSingleMemberByteAcceptDef((SingleMemberByteWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByteAcceptDef" + m + ": " + t); } } static void checkSingleMemberShortAcceptDefParam(Method m) { try { checkSingleMemberShortAcceptDef((SingleMemberShortWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShortAcceptDef" + m + ": " + t); } } static void checkSingleMemberIntAcceptDefParam(Method m) { try { checkSingleMemberIntAcceptDef((SingleMemberIntWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberIntAcceptDef" + m + ": " + t); } } static void checkSingleMemberLongAcceptDefParam(Method m) { try { checkSingleMemberLongAcceptDef((SingleMemberLongWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLongAcceptDef" + m + ": " + t); } } static void checkSingleMemberCharAcceptDefParam(Method m) { try { checkSingleMemberCharAcceptDef((SingleMemberCharWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberCharAcceptDef" + m + ": " + t); } } static void checkSingleMemberFloatAcceptDefParam(Method m) { try { checkSingleMemberFloatAcceptDef((SingleMemberFloatWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloatAcceptDef" + m + ": " + t); } } static void checkSingleMemberDoubleAcceptDefParam(Method m) { try { checkSingleMemberDoubleAcceptDef((SingleMemberDoubleWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDoubleAcceptDef" + m + ": " + t); } } static void checkSingleMemberBooleanAcceptDefParam(Method m) { try { checkSingleMemberBooleanAcceptDef((SingleMemberBooleanWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBooleanAcceptDef" + m + ": " + t); } } static void checkSingleMemberStringAcceptDefParam(Method m) { try { checkSingleMemberStringAcceptDef((SingleMemberStringWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberStringAcceptDef" + m + ": " + t); } } static void checkSingleMemberClassAcceptDefParam(Method m) { try { checkSingleMemberClassAcceptDef((SingleMemberClassWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClassAcceptDef" + m + ": " + t); } } static void checkSingleMemberEnumAcceptDefParam(Method m) { try { checkSingleMemberEnumAcceptDef((SingleMemberEnumWithDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnumAcceptDef" + m + ": " + t); } } // single-member array types (empty array) parameter static void checkSingleMemberByteArrEmptyParam(Method m) { try { checkSingleMemberByteArrEmpty((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByteArrEmpty" + m + ": " + t); } } static void checkSingleMemberShortArrEmptyParam(Method m) { try { checkSingleMemberShortArrEmpty((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShortArrEmpty" + m + ": " + t); } } static void checkSingleMemberIntArrEmptyParam(Method m) { try { checkSingleMemberIntArrEmpty((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberIntArrEmpty" + m + ": " + t); } } static void checkSingleMemberLongArrEmptyParam(Method m) { try { checkSingleMemberLongArrEmpty((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLongArrEmpty" + m + ": " + t); } } static void checkSingleMemberCharArrEmptyParam(Method m) { try { checkSingleMemberCharArrEmpty((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberCharArrEmpty" + m + ": " + t); } } static void checkSingleMemberFloatArrEmptyParam(Method m) { try { checkSingleMemberFloatArrEmpty((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloatArrEmpty" + m + ": " + t); } } static void checkSingleMemberDoubleArrEmptyParam(Method m) { try { checkSingleMemberDoubleArrEmpty((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDoubleArrEmpty" + m + ": " + t); } } static void checkSingleMemberBooleanArrEmptyParam(Method m) { try { checkSingleMemberBooleanArrEmpty((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBooleanArrEmpty" + m + ": " + t); } } static void checkSingleMemberStringArrEmptyParam(Method m) { try { checkSingleMemberStringArrEmpty((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberStringArrEmpty" + m + ": " + t); } } static void checkSingleMemberClassArrEmptyParam(Method m) { try { checkSingleMemberClassArrEmpty((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClassArrEmpty" + m + ": " + t); } } static void checkSingleMemberEnumArrEmptyParam(Method m) { try { checkSingleMemberEnumArrEmpty((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnumArrEmpty" + m + ": " + t); } } // single-member array types (one-element array) on parameter static void checkSingleMemberByteArrOneParam(Method m) { try { checkSingleMemberByteArrOne((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByteArrOne" + m + ": " + t); } } static void checkSingleMemberShortArrOneParam(Method m) { try { checkSingleMemberShortArrOne((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShortArrOne" + m + ": " + t); } } static void checkSingleMemberIntArrOneParam(Method m) { try { checkSingleMemberIntArrOne((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberIntArrOne" + m + ": " + t); } } static void checkSingleMemberLongArrOneParam(Method m) { try { checkSingleMemberLongArrOne((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLongArrOne" + m + ": " + t); } } static void checkSingleMemberCharArrOneParam(Method m) { try { checkSingleMemberCharArrOne((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberCharArrOne" + m + ": " + t); } } static void checkSingleMemberFloatArrOneParam(Method m) { try { checkSingleMemberFloatArrOne((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloatArrOne" + m + ": " + t); } } static void checkSingleMemberDoubleArrOneParam(Method m) { try { checkSingleMemberDoubleArrOne((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDoubleArrOne" + m + ": " + t); } } static void checkSingleMemberBooleanArrOneParam(Method m) { try { checkSingleMemberBooleanArrOne((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBooleanArrOne" + m + ": " + t); } } static void checkSingleMemberStringArrOneParam(Method m) { try { checkSingleMemberStringArrOne((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberStringArrOne" + m + ": " + t); } } static void checkSingleMemberClassArrOneParam(Method m) { try { checkSingleMemberClassArrOne((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClassArrOne" + m + ": " + t); } } static void checkSingleMemberEnumArrOneParam(Method m) { try { checkSingleMemberEnumArrOne((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnumArrOne" + m + ": " + t); } } // single-member array types (two-element array) on parameter static void checkSingleMemberByteArrTwoParam(Method m) { try { checkSingleMemberByteArrTwo((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByteArrTwo" + m + ": " + t); } } static void checkSingleMemberShortArrTwoParam(Method m) { try { checkSingleMemberShortArrTwo((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShortArrTwo" + m + ": " + t); } } static void checkSingleMemberIntArrTwoParam(Method m) { try { checkSingleMemberIntArrTwo((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberIntArrTwo" + m + ": " + t); } } static void checkSingleMemberLongArrTwoParam(Method m) { try { checkSingleMemberLongArrTwo((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLongArrTwo" + m + ": " + t); } } static void checkSingleMemberCharArrTwoParam(Method m) { try { checkSingleMemberCharArrTwo((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberCharArrTwo" + m + ": " + t); } } static void checkSingleMemberFloatArrTwoParam(Method m) { try { checkSingleMemberFloatArrTwo((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloatArrTwo" + m + ": " + t); } } static void checkSingleMemberDoubleArrTwoParam(Method m) { try { checkSingleMemberDoubleArrTwo((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDoubleArrTwo" + m + ": " + t); } } static void checkSingleMemberBooleanArrTwoParam(Method m) { try { checkSingleMemberBooleanArrTwo((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBooleanArrTwo" + m + ": " + t); } } static void checkSingleMemberStringArrTwoParam(Method m) { try { checkSingleMemberStringArrTwo((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberStringArrTwo" + m + ": " + t); } } static void checkSingleMemberClassArrTwoParam(Method m) { try { checkSingleMemberClassArrTwo((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClassArrTwo" + m + ": " + t); } } static void checkSingleMemberEnumArrTwoParam(Method m) { try { checkSingleMemberEnumArrTwo((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnumArrTwo" + m + ": " + t); } } // single-member array types with default (override)on parameter static void checkSingleMemberByteArrOvrdDefParam(Method m) { try { checkSingleMemberByteArrOvrdDef((SingleMemberByteArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByteArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberShortArrOvrdDefParam(Method m) { try { checkSingleMemberShortArrOvrdDef((SingleMemberShortArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShortArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberIntArrOvrdDefParam(Method m) { try { checkSingleMemberIntArrOvrdDef((SingleMemberIntArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberIntArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberLongArrOvrdDefParam(Method m) { try { checkSingleMemberLongArrOvrdDef((SingleMemberLongArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLongArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberCharArrOvrdDefParam(Method m) { try { checkSingleMemberCharArrOvrdDef((SingleMemberCharArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberCharArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberFloatArrOvrdDefParam(Method m) { try { checkSingleMemberFloatArrOvrdDef((SingleMemberFloatArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloatArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberDoubleArrOvrdDefParam(Method m) { try { checkSingleMemberDoubleArrOvrdDef((SingleMemberDoubleArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDoubleArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberBooleanArrOvrdDefParam(Method m) { try { checkSingleMemberBooleanArrOvrdDef((SingleMemberBooleanArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBooleanArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberStringArrOvrdDefParam(Method m) { try { checkSingleMemberStringArrOvrdDef((SingleMemberStringArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberStringArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberClassArrOvrdDefParam(Method m) { try { checkSingleMemberClassArrOvrdDef((SingleMemberClassArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClassArrOvrdDef" + m + ": " + t); } } static void checkSingleMemberEnumArrOvrdDefParam(Method m) { try { checkSingleMemberEnumArrOvrdDef((SingleMemberEnumArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnumArrOvrdDef" + m + ": " + t); } } // single-member array types with default (accept)on parameter static void checkSingleMemberByteArrAcceptDefParam(Method m) { try { checkSingleMemberByteArrAcceptDef((SingleMemberByteArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberByteArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberShortArrAcceptDefParam(Method m) { try { checkSingleMemberShortArrAcceptDef((SingleMemberShortArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberShortArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberIntArrAcceptDefParam(Method m) { try { checkSingleMemberIntArrAcceptDef((SingleMemberIntArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberIntArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberLongArrAcceptDefParam(Method m) { try { checkSingleMemberLongArrAcceptDef((SingleMemberLongArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberLongArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberCharArrAcceptDefParam(Method m) { try { checkSingleMemberCharArrAcceptDef((SingleMemberCharArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberCharArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberFloatArrAcceptDefParam(Method m) { try { checkSingleMemberFloatArrAcceptDef((SingleMemberFloatArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberFloatArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberDoubleArrAcceptDefParam(Method m) { try { checkSingleMemberDoubleArrAcceptDef((SingleMemberDoubleArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberDoubleArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberBooleanArrAcceptDefParam(Method m) { try { checkSingleMemberBooleanArrAcceptDef((SingleMemberBooleanArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberBooleanArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberStringArrAcceptDefParam(Method m) { try { checkSingleMemberStringArrAcceptDef((SingleMemberStringArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberStringArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberClassArrAcceptDefParam(Method m) { try { checkSingleMemberClassArrAcceptDef((SingleMemberClassArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberClassArrAcceptDef" + m + ": " + t); } } static void checkSingleMemberEnumArrAcceptDefParam(Method m) { try { checkSingleMemberEnumArrAcceptDef((SingleMemberEnumArrayDef) m.getParameterAnnotations()[0][0], m); } catch(Throwable t) { fail("SingleMemberEnumArrAcceptDef" + m + ": " + t); } } // Marker static void checkMarker(AnnotatedElement e) { checkMarker(e.getAnnotation(Marker.class), e); } static void checkMarker(Marker m, AnnotatedElement e) { numTests++; try { if (m == null) fail("Marker " + e); } catch(Throwable t) { fail("Marker " + e + ": " + t); } } // Single-member static void checkSingleMemberByte(AnnotatedElement e) { checkSingleMemberByte(e.getAnnotation(SingleMemberByte.class), e); } static void checkSingleMemberByte(SingleMemberByte a, AnnotatedElement e) { numTests++; try { if (a.value() != 1) fail("SingleMemberByte " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByte " + e + ": " + t); } } static void checkSingleMemberShort(AnnotatedElement e) { checkSingleMemberShort(e.getAnnotation(SingleMemberShort.class), e); } static void checkSingleMemberShort(SingleMemberShort a, AnnotatedElement e) { numTests++; try { if (a.value() != 2) fail("SingleMemberShort " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShort " + e + ": " + t); } } static void checkSingleMemberInt(AnnotatedElement e) { checkSingleMemberInt(e.getAnnotation(SingleMemberInt.class), e); } static void checkSingleMemberInt(SingleMemberInt a, AnnotatedElement e) { numTests++; try { if (a.value() != 3) fail("SingleMemberInt " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberInt " + e + ": " + t); } } static void checkSingleMemberLong(AnnotatedElement e) { checkSingleMemberLong(e.getAnnotation(SingleMemberLong.class), e); } static void checkSingleMemberLong(SingleMemberLong a, AnnotatedElement e) { numTests++; try { if (a.value() != 4L) fail("SingleMemberLong " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLong " + e + ": " + t); } } static void checkSingleMemberChar(AnnotatedElement e) { checkSingleMemberChar(e.getAnnotation(SingleMemberChar.class), e); } static void checkSingleMemberChar(SingleMemberChar a, AnnotatedElement e) { numTests++; try { if (a.value() != '5') fail("SingleMemberChar " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberChar " + e + ": " + t); } } static void checkSingleMemberFloat(AnnotatedElement e) { checkSingleMemberFloat(e.getAnnotation(SingleMemberFloat.class), e); } static void checkSingleMemberFloat(SingleMemberFloat a, AnnotatedElement e) { numTests++; try { if (a.value() != 6.0f) fail("SingleMemberFloat " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloat " + e + ": " + t); } } static void checkSingleMemberDouble(AnnotatedElement e) { checkSingleMemberDouble(e.getAnnotation(SingleMemberDouble.class), e); } static void checkSingleMemberDouble(SingleMemberDouble a, AnnotatedElement e) { numTests++; try { if (a.value() != 7.0) fail("SingleMemberDouble " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDouble " + e + ": " + t); } } static void checkSingleMemberBoolean(AnnotatedElement e) { checkSingleMemberBoolean(e.getAnnotation(SingleMemberBoolean.class), e); } static void checkSingleMemberBoolean(SingleMemberBoolean a, AnnotatedElement e) { numTests++; try { if (!a.value()) fail("SingleMemberBoolean " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBoolean " + e + ": " + t); } } static void checkSingleMemberString(AnnotatedElement e) { checkSingleMemberString(e.getAnnotation(SingleMemberString.class), e); } static void checkSingleMemberString(SingleMemberString a, AnnotatedElement e) { numTests++; try { if (!(a.value().equals("custom"))) fail("SingleMemberString " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberString " + e + ": " + t); } } static void checkSingleMemberClass(AnnotatedElement e) { checkSingleMemberClass(e.getAnnotation(SingleMemberClass.class), e); } static void checkSingleMemberClass(SingleMemberClass a, AnnotatedElement e) { numTests++; try { if (a.value() != Map.class) fail("SingleMemberClass " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClass " + e + ": " + t); } } static void checkSingleMemberEnum(AnnotatedElement e) { checkSingleMemberEnum(e.getAnnotation(SingleMemberEnum.class), e); } static void checkSingleMemberEnum(SingleMemberEnum a, AnnotatedElement e) { numTests++; try { if (a.value() != Stooge.MOE) fail("SingleMemberEnum " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnum " + e + ": " + t); } } // Single-member with default (Override) static void checkSingleMemberByteOvrdDef(AnnotatedElement e) { checkSingleMemberByteOvrdDef(e.getAnnotation(SingleMemberByteWithDef.class), e); } static void checkSingleMemberByteOvrdDef(SingleMemberByteWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 1) fail("SingleMemberByteOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByteOvrdDef " + e + ": " + t); } } static void checkSingleMemberShortOvrdDef(AnnotatedElement e) { checkSingleMemberShortOvrdDef(e.getAnnotation(SingleMemberShortWithDef.class), e); } static void checkSingleMemberShortOvrdDef(SingleMemberShortWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 2) fail("SingleMemberShortOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShortOvrdDef " + e + ": " + t); } } static void checkSingleMemberIntOvrdDef(AnnotatedElement e) { checkSingleMemberIntOvrdDef(e.getAnnotation(SingleMemberIntWithDef.class), e); } static void checkSingleMemberIntOvrdDef(SingleMemberIntWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 3) fail("SingleMemberIntOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberIntOvrdDef " + e + ": " + t); } } static void checkSingleMemberLongOvrdDef(AnnotatedElement e) { checkSingleMemberLongOvrdDef(e.getAnnotation(SingleMemberLongWithDef.class), e); } static void checkSingleMemberLongOvrdDef(SingleMemberLongWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 4L) fail("SingleMemberLongOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLongOvrdDef " + e + ": " + t); } } static void checkSingleMemberCharOvrdDef(AnnotatedElement e) { checkSingleMemberCharOvrdDef(e.getAnnotation(SingleMemberCharWithDef.class), e); } static void checkSingleMemberCharOvrdDef(SingleMemberCharWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != '5') fail("SingleMemberCharOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberCharOvrdDef " + e + ": " + t); } } static void checkSingleMemberFloatOvrdDef(AnnotatedElement e) { checkSingleMemberFloatOvrdDef(e.getAnnotation(SingleMemberFloatWithDef.class), e); } static void checkSingleMemberFloatOvrdDef(SingleMemberFloatWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 6.0f) fail("SingleMemberFloatOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloatOvrdDef " + e + ": " + t); } } static void checkSingleMemberDoubleOvrdDef(AnnotatedElement e) { checkSingleMemberDoubleOvrdDef(e.getAnnotation(SingleMemberDoubleWithDef.class), e); } static void checkSingleMemberDoubleOvrdDef(SingleMemberDoubleWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 7.0) fail("SingleMemberDoubleOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDoubleOvrdDef " + e + ": " + t); } } static void checkSingleMemberBooleanOvrdDef(AnnotatedElement e) { checkSingleMemberBooleanOvrdDef(e.getAnnotation(SingleMemberBooleanWithDef.class), e); } static void checkSingleMemberBooleanOvrdDef(SingleMemberBooleanWithDef a, AnnotatedElement e) { numTests++; try { if (!a.value()) fail("SingleMemberBooleanOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBooleanOvrdDef " + e + ": " + t); } } static void checkSingleMemberStringOvrdDef(AnnotatedElement e) { checkSingleMemberStringOvrdDef(e.getAnnotation(SingleMemberStringWithDef.class), e); } static void checkSingleMemberStringOvrdDef(SingleMemberStringWithDef a, AnnotatedElement e) { numTests++; try { if (!(a.value().equals("custom"))) fail("SingleMemberStringOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberStringOvrdDef " + e + ": " + t); } } static void checkSingleMemberClassOvrdDef(AnnotatedElement e) { checkSingleMemberClassOvrdDef(e.getAnnotation(SingleMemberClassWithDef.class), e); } static void checkSingleMemberClassOvrdDef(SingleMemberClassWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != Map.class) fail("SingleMemberClassOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClassOvrdDef " + e + ": " + t); } } static void checkSingleMemberEnumOvrdDef(AnnotatedElement e) { checkSingleMemberEnumOvrdDef(e.getAnnotation(SingleMemberEnumWithDef.class), e); } static void checkSingleMemberEnumOvrdDef(SingleMemberEnumWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != Stooge.MOE) fail("SingleMemberEnumOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnumOvrdDef " + e + ": " + t); } } // Single-member with default (Accept) static void checkSingleMemberByteAcceptDef(AnnotatedElement e) { checkSingleMemberByteAcceptDef(e.getAnnotation(SingleMemberByteWithDef.class), e); } static void checkSingleMemberByteAcceptDef(SingleMemberByteWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 11) fail("SingleMemberByteAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByteAcceptDef " + e + ": " + t); } } static void checkSingleMemberShortAcceptDef(AnnotatedElement e) { checkSingleMemberShortAcceptDef(e.getAnnotation(SingleMemberShortWithDef.class), e); } static void checkSingleMemberShortAcceptDef(SingleMemberShortWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 12) fail("SingleMemberShortAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShortAcceptDef " + e + ": " + t); } } static void checkSingleMemberIntAcceptDef(AnnotatedElement e) { checkSingleMemberIntAcceptDef(e.getAnnotation(SingleMemberIntWithDef.class), e); } static void checkSingleMemberIntAcceptDef(SingleMemberIntWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 13) fail("SingleMemberIntAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberIntAcceptDef " + e + ": " + t); } } static void checkSingleMemberLongAcceptDef(AnnotatedElement e) { checkSingleMemberLongAcceptDef(e.getAnnotation(SingleMemberLongWithDef.class), e); } static void checkSingleMemberLongAcceptDef(SingleMemberLongWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 14L) fail("SingleMemberLongAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLongAcceptDef " + e + ": " + t); } } static void checkSingleMemberCharAcceptDef(AnnotatedElement e) { checkSingleMemberCharAcceptDef(e.getAnnotation(SingleMemberCharWithDef.class), e); } static void checkSingleMemberCharAcceptDef(SingleMemberCharWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 'V') fail("SingleMemberCharAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberCharAcceptDef " + e + ": " + t); } } static void checkSingleMemberFloatAcceptDef(AnnotatedElement e) { checkSingleMemberFloatAcceptDef(e.getAnnotation(SingleMemberFloatWithDef.class), e); } static void checkSingleMemberFloatAcceptDef(SingleMemberFloatWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 16.0f) fail("SingleMemberFloatAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloatAcceptDef " + e + ": " + t); } } static void checkSingleMemberDoubleAcceptDef(AnnotatedElement e) { checkSingleMemberDoubleAcceptDef(e.getAnnotation(SingleMemberDoubleWithDef.class), e); } static void checkSingleMemberDoubleAcceptDef(SingleMemberDoubleWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != 17.0) fail("SingleMemberDoubleAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDoubleAcceptDef " + e + ": " + t); } } static void checkSingleMemberBooleanAcceptDef(AnnotatedElement e) { checkSingleMemberBooleanAcceptDef(e.getAnnotation(SingleMemberBooleanWithDef.class), e); } static void checkSingleMemberBooleanAcceptDef(SingleMemberBooleanWithDef a, AnnotatedElement e) { numTests++; try { if (a.value()) fail("SingleMemberBooleanAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBooleanAcceptDef " + e + ": " + t); } } static void checkSingleMemberStringAcceptDef(AnnotatedElement e) { checkSingleMemberStringAcceptDef(e.getAnnotation(SingleMemberStringWithDef.class), e); } static void checkSingleMemberStringAcceptDef(SingleMemberStringWithDef a, AnnotatedElement e) { numTests++; try { if (!(a.value().equals("default"))) fail("SingleMemberStringAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberStringAcceptDef " + e + ": " + t); } } static void checkSingleMemberClassAcceptDef(AnnotatedElement e) { checkSingleMemberClassAcceptDef(e.getAnnotation(SingleMemberClassWithDef.class), e); } static void checkSingleMemberClassAcceptDef(SingleMemberClassWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != Class.class) fail("SingleMemberClassAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClassAcceptDef " + e + ": " + t); } } static void checkSingleMemberEnumAcceptDef(AnnotatedElement e) { checkSingleMemberEnumAcceptDef(e.getAnnotation(SingleMemberEnumWithDef.class), e); } static void checkSingleMemberEnumAcceptDef(SingleMemberEnumWithDef a, AnnotatedElement e) { numTests++; try { if (a.value() != Stooge.LARRY) fail("SingleMemberEnumAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnumAcceptDef " + e + ": " + t); } } // Single member array (empty array) static void checkSingleMemberByteArrEmpty(AnnotatedElement e) { checkSingleMemberByteArrEmpty(e.getAnnotation(SingleMemberByteArray.class), e); } static void checkSingleMemberByteArrEmpty(SingleMemberByteArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberByteArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByteArrEmpty " + e + ": " + t); } } static void checkSingleMemberShortArrEmpty(AnnotatedElement e) { checkSingleMemberShortArrEmpty(e.getAnnotation(SingleMemberShortArray.class), e); } static void checkSingleMemberShortArrEmpty(SingleMemberShortArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberShortArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShortArrEmpty " + e + ": " + t); } } static void checkSingleMemberIntArrEmpty(AnnotatedElement e) { checkSingleMemberIntArrEmpty(e.getAnnotation(SingleMemberIntArray.class), e); } static void checkSingleMemberIntArrEmpty(SingleMemberIntArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberIntArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberIntArrEmpty " + e + ": " + t); } } static void checkSingleMemberLongArrEmpty(AnnotatedElement e) { checkSingleMemberLongArrEmpty(e.getAnnotation(SingleMemberLongArray.class), e); } static void checkSingleMemberLongArrEmpty(SingleMemberLongArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberLongArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLongArrEmpty " + e + ": " + t); } } static void checkSingleMemberCharArrEmpty(AnnotatedElement e) { checkSingleMemberCharArrEmpty(e.getAnnotation(SingleMemberCharArray.class), e); } static void checkSingleMemberCharArrEmpty(SingleMemberCharArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberCharArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberCharArrEmpty " + e + ": " + t); } } static void checkSingleMemberFloatArrEmpty(AnnotatedElement e) { checkSingleMemberFloatArrEmpty(e.getAnnotation(SingleMemberFloatArray.class), e); } static void checkSingleMemberFloatArrEmpty(SingleMemberFloatArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberFloatArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloatArrEmpty " + e + ": " + t); } } static void checkSingleMemberDoubleArrEmpty(AnnotatedElement e) { checkSingleMemberDoubleArrEmpty(e.getAnnotation(SingleMemberDoubleArray.class), e); } static void checkSingleMemberDoubleArrEmpty(SingleMemberDoubleArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberDoubleArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDoubleArrEmpty " + e + ": " + t); } } static void checkSingleMemberBooleanArrEmpty(AnnotatedElement e) { checkSingleMemberBooleanArrEmpty(e.getAnnotation(SingleMemberBooleanArray.class), e); } static void checkSingleMemberBooleanArrEmpty(SingleMemberBooleanArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberBooleanArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBooleanArrEmpty " + e + ": " + t); } } static void checkSingleMemberStringArrEmpty(AnnotatedElement e) { checkSingleMemberStringArrEmpty(e.getAnnotation(SingleMemberStringArray.class), e); } static void checkSingleMemberStringArrEmpty(SingleMemberStringArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberStringArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberStringArrEmpty " + e + ": " + t); } } static void checkSingleMemberClassArrEmpty(AnnotatedElement e) { checkSingleMemberClassArrEmpty(e.getAnnotation(SingleMemberClassArray.class), e); } static void checkSingleMemberClassArrEmpty(SingleMemberClassArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberClassArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClassArrEmpty " + e + ": " + t); } } static void checkSingleMemberEnumArrEmpty(AnnotatedElement e) { checkSingleMemberEnumArrEmpty(e.getAnnotation(SingleMemberEnumArray.class), e); } static void checkSingleMemberEnumArrEmpty(SingleMemberEnumArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 0) fail("SingleMemberEnumArrEmpty " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnumArrEmpty " + e + ": " + t); } } // Single member array (one element array) static void checkSingleMemberByteArrOne(AnnotatedElement e) { checkSingleMemberByteArrOne(e.getAnnotation(SingleMemberByteArray.class), e); } static void checkSingleMemberByteArrOne(SingleMemberByteArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != (byte)1) fail("SingleMemberByteArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByteArrOne " + e + ": " + t); } } static void checkSingleMemberShortArrOne(AnnotatedElement e) { checkSingleMemberShortArrOne(e.getAnnotation(SingleMemberShortArray.class), e); } static void checkSingleMemberShortArrOne(SingleMemberShortArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != (short)2) fail("SingleMemberShortArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShortArrOne " + e + ": " + t); } } static void checkSingleMemberIntArrOne(AnnotatedElement e) { checkSingleMemberIntArrOne(e.getAnnotation(SingleMemberIntArray.class), e); } static void checkSingleMemberIntArrOne(SingleMemberIntArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 3) fail("SingleMemberIntArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberIntArrOne " + e + ": " + t); } } static void checkSingleMemberLongArrOne(AnnotatedElement e) { checkSingleMemberLongArrOne(e.getAnnotation(SingleMemberLongArray.class), e); } static void checkSingleMemberLongArrOne(SingleMemberLongArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 4L) fail("SingleMemberLongArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLongArrOne " + e + ": " + t); } } static void checkSingleMemberCharArrOne(AnnotatedElement e) { checkSingleMemberCharArrOne(e.getAnnotation(SingleMemberCharArray.class), e); } static void checkSingleMemberCharArrOne(SingleMemberCharArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != '5') fail("SingleMemberCharArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberCharArrOne " + e + ": " + t); } } static void checkSingleMemberFloatArrOne(AnnotatedElement e) { checkSingleMemberFloatArrOne(e.getAnnotation(SingleMemberFloatArray.class), e); } static void checkSingleMemberFloatArrOne(SingleMemberFloatArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 6.0f) fail("SingleMemberFloatArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloatArrOne " + e + ": " + t); } } static void checkSingleMemberDoubleArrOne(AnnotatedElement e) { checkSingleMemberDoubleArrOne(e.getAnnotation(SingleMemberDoubleArray.class), e); } static void checkSingleMemberDoubleArrOne(SingleMemberDoubleArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 7.0) fail("SingleMemberDoubleArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDoubleArrOne " + e + ": " + t); } } static void checkSingleMemberBooleanArrOne(AnnotatedElement e) { checkSingleMemberBooleanArrOne(e.getAnnotation(SingleMemberBooleanArray.class), e); } static void checkSingleMemberBooleanArrOne(SingleMemberBooleanArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || !a.value()[0]) fail("SingleMemberBooleanArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBooleanArrOne " + e + ": " + t); } } static void checkSingleMemberStringArrOne(AnnotatedElement e) { checkSingleMemberStringArrOne(e.getAnnotation(SingleMemberStringArray.class), e); } static void checkSingleMemberStringArrOne(SingleMemberStringArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || !(a.value()[0].equals("custom"))) fail("SingleMemberStringArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberStringArrOne " + e + ": " + t); } } static void checkSingleMemberClassArrOne(AnnotatedElement e) { checkSingleMemberClassArrOne(e.getAnnotation(SingleMemberClassArray.class), e); } static void checkSingleMemberClassArrOne(SingleMemberClassArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != Map.class) fail("SingleMemberClassArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClassArrOne " + e + ": " + t); } } static void checkSingleMemberEnumArrOne(AnnotatedElement e) { checkSingleMemberEnumArrOne(e.getAnnotation(SingleMemberEnumArray.class), e); } static void checkSingleMemberEnumArrOne(SingleMemberEnumArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != Stooge.MOE) fail("SingleMemberEnumArrOne " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnumArrOne " + e + ": " + t); } } // Single member array (two element array) static void checkSingleMemberByteArrTwo(AnnotatedElement e) { checkSingleMemberByteArrTwo(e.getAnnotation(SingleMemberByteArray.class), e); } static void checkSingleMemberByteArrTwo(SingleMemberByteArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != (byte)1 || a.value()[1] != (byte)2) fail("SingleMemberByteArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByteArrTwo " + e + ": " + t); } } static void checkSingleMemberShortArrTwo(AnnotatedElement e) { checkSingleMemberShortArrTwo(e.getAnnotation(SingleMemberShortArray.class), e); } static void checkSingleMemberShortArrTwo(SingleMemberShortArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != (short)2 || a.value()[1] != (short)3) fail("SingleMemberShortArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShortArrTwo " + e + ": " + t); } } static void checkSingleMemberIntArrTwo(AnnotatedElement e) { checkSingleMemberIntArrTwo(e.getAnnotation(SingleMemberIntArray.class), e); } static void checkSingleMemberIntArrTwo(SingleMemberIntArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != 3 || a.value()[1] != 4) fail("SingleMemberIntArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberIntArrTwo " + e + ": " + t); } } static void checkSingleMemberLongArrTwo(AnnotatedElement e) { checkSingleMemberLongArrTwo(e.getAnnotation(SingleMemberLongArray.class), e); } static void checkSingleMemberLongArrTwo(SingleMemberLongArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != 4L || a.value()[1] != 5L) fail("SingleMemberLongArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLongArrTwo " + e + ": " + t); } } static void checkSingleMemberCharArrTwo(AnnotatedElement e) { checkSingleMemberCharArrTwo(e.getAnnotation(SingleMemberCharArray.class), e); } static void checkSingleMemberCharArrTwo(SingleMemberCharArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != '5' || a.value()[1] != '6') fail("SingleMemberCharArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberCharArrTwo " + e + ": " + t); } } static void checkSingleMemberFloatArrTwo(AnnotatedElement e) { checkSingleMemberFloatArrTwo(e.getAnnotation(SingleMemberFloatArray.class), e); } static void checkSingleMemberFloatArrTwo(SingleMemberFloatArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != 6.0f || a.value()[1] != 7.0f) fail("SingleMemberFloatArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloatArrTwo " + e + ": " + t); } } static void checkSingleMemberDoubleArrTwo(AnnotatedElement e) { checkSingleMemberDoubleArrTwo(e.getAnnotation(SingleMemberDoubleArray.class), e); } static void checkSingleMemberDoubleArrTwo(SingleMemberDoubleArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != 7.0 || a.value()[1] != 8.0) fail("SingleMemberDoubleArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDoubleArrTwo " + e + ": " + t); } } static void checkSingleMemberBooleanArrTwo(AnnotatedElement e) { checkSingleMemberBooleanArrTwo(e.getAnnotation(SingleMemberBooleanArray.class), e); } static void checkSingleMemberBooleanArrTwo(SingleMemberBooleanArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || !a.value()[0] || a.value()[1]) fail("SingleMemberBooleanArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBooleanArrTwo " + e + ": " + t); } } static void checkSingleMemberStringArrTwo(AnnotatedElement e) { checkSingleMemberStringArrTwo(e.getAnnotation(SingleMemberStringArray.class), e); } static void checkSingleMemberStringArrTwo(SingleMemberStringArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || !(a.value()[0].equals("custom")) || !(a.value()[1].equals("paint"))) fail("SingleMemberStringArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberStringArrTwo " + e + ": " + t); } } static void checkSingleMemberClassArrTwo(AnnotatedElement e) { checkSingleMemberClassArrTwo(e.getAnnotation(SingleMemberClassArray.class), e); } static void checkSingleMemberClassArrTwo(SingleMemberClassArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != Map.class || a.value()[1] != Set.class) fail("SingleMemberClassArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClassArrTwo " + e + ": " + t); } } static void checkSingleMemberEnumArrTwo(AnnotatedElement e) { checkSingleMemberEnumArrTwo(e.getAnnotation(SingleMemberEnumArray.class), e); } static void checkSingleMemberEnumArrTwo(SingleMemberEnumArray a, AnnotatedElement e) { numTests++; try { if (a.value().length != 2 || a.value()[0] != Stooge.MOE || a.value()[1] != Stooge.CURLY) fail("SingleMemberEnumArrTwo " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnumArrTwo " + e + ": " + t); } } // Single member array with default (override) static void checkSingleMemberByteArrOvrdDef(AnnotatedElement e) { checkSingleMemberByteArrOvrdDef(e.getAnnotation(SingleMemberByteArrayDef.class), e); } static void checkSingleMemberByteArrOvrdDef(SingleMemberByteArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != (byte)1) fail("SingleMemberByteArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByteArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberShortArrOvrdDef(AnnotatedElement e) { checkSingleMemberShortArrOvrdDef(e.getAnnotation(SingleMemberShortArrayDef.class), e); } static void checkSingleMemberShortArrOvrdDef(SingleMemberShortArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != (short)2) fail("SingleMemberShortArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShortArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberIntArrOvrdDef(AnnotatedElement e) { checkSingleMemberIntArrOvrdDef(e.getAnnotation(SingleMemberIntArrayDef.class), e); } static void checkSingleMemberIntArrOvrdDef(SingleMemberIntArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 3) fail("SingleMemberIntArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberIntArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberLongArrOvrdDef(AnnotatedElement e) { checkSingleMemberLongArrOvrdDef(e.getAnnotation(SingleMemberLongArrayDef.class), e); } static void checkSingleMemberLongArrOvrdDef(SingleMemberLongArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 4L) fail("SingleMemberLongArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLongArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberCharArrOvrdDef(AnnotatedElement e) { checkSingleMemberCharArrOvrdDef(e.getAnnotation(SingleMemberCharArrayDef.class), e); } static void checkSingleMemberCharArrOvrdDef(SingleMemberCharArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != '5') fail("SingleMemberCharArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberCharArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberFloatArrOvrdDef(AnnotatedElement e) { checkSingleMemberFloatArrOvrdDef(e.getAnnotation(SingleMemberFloatArrayDef.class), e); } static void checkSingleMemberFloatArrOvrdDef(SingleMemberFloatArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 6.0f) fail("SingleMemberFloatArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloatArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberDoubleArrOvrdDef(AnnotatedElement e) { checkSingleMemberDoubleArrOvrdDef(e.getAnnotation(SingleMemberDoubleArrayDef.class), e); } static void checkSingleMemberDoubleArrOvrdDef(SingleMemberDoubleArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 7.0) fail("SingleMemberDoubleArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDoubleArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberBooleanArrOvrdDef(AnnotatedElement e) { checkSingleMemberBooleanArrOvrdDef(e.getAnnotation(SingleMemberBooleanArrayDef.class), e); } static void checkSingleMemberBooleanArrOvrdDef(SingleMemberBooleanArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || !a.value()[0]) fail("SingleMemberBooleanArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBooleanArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberStringArrOvrdDef(AnnotatedElement e) { checkSingleMemberStringArrOvrdDef(e.getAnnotation(SingleMemberStringArrayDef.class), e); } static void checkSingleMemberStringArrOvrdDef(SingleMemberStringArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || !(a.value()[0].equals("custom"))) fail("SingleMemberStringArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberStringArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberClassArrOvrdDef(AnnotatedElement e) { checkSingleMemberClassArrOvrdDef(e.getAnnotation(SingleMemberClassArrayDef.class), e); } static void checkSingleMemberClassArrOvrdDef(SingleMemberClassArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != Map.class) fail("SingleMemberClassArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClassArrOvrdDef " + e + ": " + t); } } static void checkSingleMemberEnumArrOvrdDef(AnnotatedElement e) { checkSingleMemberEnumArrOvrdDef(e.getAnnotation(SingleMemberEnumArrayDef.class), e); } static void checkSingleMemberEnumArrOvrdDef(SingleMemberEnumArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != Stooge.MOE) fail("SingleMemberEnumArrOvrdDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnumArrOvrdDef " + e + ": " + t); } } // Single member array with default (accept) static void checkSingleMemberByteArrAcceptDef(AnnotatedElement e) { checkSingleMemberByteArrAcceptDef(e.getAnnotation(SingleMemberByteArrayDef.class), e); } static void checkSingleMemberByteArrAcceptDef(SingleMemberByteArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != (byte)11) fail("SingleMemberByteArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberByteArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberShortArrAcceptDef(AnnotatedElement e) { checkSingleMemberShortArrAcceptDef(e.getAnnotation(SingleMemberShortArrayDef.class), e); } static void checkSingleMemberShortArrAcceptDef(SingleMemberShortArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != (short)12) fail("SingleMemberShortArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberShortArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberIntArrAcceptDef(AnnotatedElement e) { checkSingleMemberIntArrAcceptDef(e.getAnnotation(SingleMemberIntArrayDef.class), e); } static void checkSingleMemberIntArrAcceptDef(SingleMemberIntArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 13) fail("SingleMemberIntArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberIntArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberLongArrAcceptDef(AnnotatedElement e) { checkSingleMemberLongArrAcceptDef(e.getAnnotation(SingleMemberLongArrayDef.class), e); } static void checkSingleMemberLongArrAcceptDef(SingleMemberLongArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 14L) fail("SingleMemberLongArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberLongArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberCharArrAcceptDef(AnnotatedElement e) { checkSingleMemberCharArrAcceptDef(e.getAnnotation(SingleMemberCharArrayDef.class), e); } static void checkSingleMemberCharArrAcceptDef(SingleMemberCharArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 'V') fail("SingleMemberCharArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberCharArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberFloatArrAcceptDef(AnnotatedElement e) { checkSingleMemberFloatArrAcceptDef(e.getAnnotation(SingleMemberFloatArrayDef.class), e); } static void checkSingleMemberFloatArrAcceptDef(SingleMemberFloatArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 16.0f) fail("SingleMemberFloatArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberFloatArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberDoubleArrAcceptDef(AnnotatedElement e) { checkSingleMemberDoubleArrAcceptDef(e.getAnnotation(SingleMemberDoubleArrayDef.class), e); } static void checkSingleMemberDoubleArrAcceptDef(SingleMemberDoubleArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != 17.0) fail("SingleMemberDoubleArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberDoubleArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberBooleanArrAcceptDef(AnnotatedElement e) { checkSingleMemberBooleanArrAcceptDef(e.getAnnotation(SingleMemberBooleanArrayDef.class), e); } static void checkSingleMemberBooleanArrAcceptDef(SingleMemberBooleanArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0]) fail("SingleMemberBooleanArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberBooleanArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberStringArrAcceptDef(AnnotatedElement e) { checkSingleMemberStringArrAcceptDef(e.getAnnotation(SingleMemberStringArrayDef.class), e); } static void checkSingleMemberStringArrAcceptDef(SingleMemberStringArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || !(a.value()[0].equals("default"))) fail("SingleMemberStringArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberStringArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberClassArrAcceptDef(AnnotatedElement e) { checkSingleMemberClassArrAcceptDef(e.getAnnotation(SingleMemberClassArrayDef.class), e); } static void checkSingleMemberClassArrAcceptDef(SingleMemberClassArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != Class.class) fail("SingleMemberClassArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberClassArrAcceptDef " + e + ": " + t); } } static void checkSingleMemberEnumArrAcceptDef(AnnotatedElement e) { checkSingleMemberEnumArrAcceptDef(e.getAnnotation(SingleMemberEnumArrayDef.class), e); } static void checkSingleMemberEnumArrAcceptDef(SingleMemberEnumArrayDef a, AnnotatedElement e) { numTests++; try { if (a.value().length != 1 || a.value()[0] != Stooge.LARRY) fail("SingleMemberEnumArrAcceptDef " + e + " = " + a.value()); } catch(Throwable t) { fail("SingleMemberEnumArrAcceptDef " + e + ": " + t); } } // Verfification methods for equals/hashCode/serialization static <T extends Annotation> void checkEquals(AnnotatedElement e1, AnnotatedElement e2, Class Other Java examples (source code examples)Here is a short list of links related to this Java UnitTest.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.