6601457: Move wrapper class tests from closed to open
6601458: Move java.math tests from closed to open
6740185: Move java/lang/annotations tests to open
6759433: Move Math and StrictMath regression tests from closed to open
Summary: Move some more regression tests to the open
Reviewed-by: jjg
diff --git a/test/java/lang/annotation/UnitTest.java b/test/java/lang/annotation/UnitTest.java
new file mode 100644
index 0000000..ed8b05c
--- /dev/null
+++ b/test/java/lang/annotation/UnitTest.java
@@ -0,0 +1,4983 @@
+/*
+ * Copyright 2003-2004 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.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
+ * @compile -source 1.5 UnitTest.java
+ * @run main UnitTest
+ */
+
+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<T> annoType) {
+ numTests++;
+ T a1 = e1.getAnnotation(annoType);
+ T a2 = e2.getAnnotation(annoType);
+ try {
+ if (!a1.equals(a2))
+ fail(a1 + " != " + a2);
+ if (a1.hashCode() != a2.hashCode())
+ fail(a1 + ".hashCode() [" + a1.hashCode() + "] != " + a2 + " .hashCode()["+ a2.hashCode()+"]");
+ if (!(a1.toString().equals(a2.toString())))
+ fail(a1 + ".toString() != " + a2 + ".toString()");
+ } catch(Throwable t) {
+ fail(a1 + " == " + a2 + ": " + t);
+ }
+ }
+
+ static <T extends Annotation> void checkUnequals(AnnotatedElement e1, AnnotatedElement e2, Class<T> annoType) {
+ numTests++;
+ T a1 = e1.getAnnotation(annoType);
+ T a2 = e2.getAnnotation(annoType);
+ try {
+ if (a1.equals(a2))
+ fail(a1 + " == " + a2);
+ if (a1.hashCode() == a2.hashCode())
+ fail(a1 + ".hashCode() [" + a1.hashCode() + "] == " + a2 + " .hashCode()[" + a2.hashCode() + "]");
+ if (a1.toString().equals(a2.toString()))
+ fail(a1 + ".toString() == " + a2 + ".toString()");
+ } catch(Throwable t) {
+ fail(a1 + " != " + a2 + ": " + t);
+ }
+ }
+
+ // Verfification method for serialization/deserialization
+
+ static <T extends Annotation> void checkSerialization(AnnotatedElement e, Class<T> annoType) {
+ numTests++;
+ T a1 = e.getAnnotation(annoType);
+ Object a2 = deepCopy(a1);
+ try {
+ if (!a1.equals(a2))
+ fail("Serialization: " + a1 + " != " + a2);
+ if (a1.hashCode() != a2.hashCode())
+ fail("Serialization: " + a1 + ".hashCode() [" + a1.hashCode() + "] != " + a2 + " .hashCode()["+a2.hashCode()+"]");
+ if (!(a1.toString().equals(a2.toString())))
+ fail("Serialization: " + a1 + ".toString() != " + a2 + ".toString()");
+ } catch(Throwable t) {
+ fail("Serialization: " + a1 + " == " + a2 + ": " + t);
+ }
+ }
+
+ private static Object deepCopy(Object original) {
+ try {
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ ObjectOutputStream oos = new ObjectOutputStream(bos);
+ oos.writeObject(original);
+ oos.flush();
+ ByteArrayInputStream bin = new ByteArrayInputStream(
+ bos.toByteArray());
+ ObjectInputStream ois = new ObjectInputStream(bin);
+ return ois.readObject();
+ } catch(Exception e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ // Verification method for inheritance test
+ static void checkInheritence(AnnotatedElement e, boolean shouldHaveFoo, boolean shouldHaveBar) {
+ numTests++;
+ try {
+ boolean hasFoo = e.isAnnotationPresent(Foo.class);
+ boolean hasBar = e.isAnnotationPresent(Bar.class);
+ if (hasFoo != shouldHaveFoo || hasBar != shouldHaveBar)
+ fail("Inheritance(1): " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar);
+
+ // Now test getAnnotations
+ hasFoo = hasBar = false;
+ Annotation[] allAnnotations = e.getAnnotations();
+ for (Annotation a : allAnnotations) {
+ if (a instanceof Foo)
+ hasFoo = true;
+ else if (a instanceof Bar)
+ hasBar = true;
+ }
+ if (hasFoo != shouldHaveFoo ||hasBar != shouldHaveBar)
+ fail("Inheritance(2): " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar);
+ } catch(Throwable t) {
+ fail("Inheritance: " + e +": " + t);
+ }
+ }
+
+ // Verification method for declared annotations test
+ static void checkDeclaredAnnotations(AnnotatedElement e, boolean shouldHaveFoo, boolean shouldHaveBar) {
+ numTests++;
+ try {
+ boolean hasFoo = false;
+ boolean hasBar = false;
+ Annotation[] declaredAnnotations = e.getDeclaredAnnotations();
+ for (Annotation a : declaredAnnotations) {
+ if (a instanceof Foo)
+ hasFoo = true;
+ else if (a instanceof Bar)
+ hasBar = true;
+ }
+ if (hasFoo != shouldHaveFoo ||hasBar != shouldHaveBar)
+ fail("Declared annotations: " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar);
+ } catch(Throwable t) {
+ fail("Declared annotations: " + e +": " + t);
+ }
+ }
+
+
+ // ANNOTATED METHODS
+
+ @ScalarTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ public void scalarTypesMethod() { }
+
+ @ScalarTypesWithDefault ( )
+ public void scalarTypesAcceptDefaultMethod() { }
+
+ @ScalarTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE
+ )
+ public void scalarTypesOverrideDefaultMethod() { }
+
+ @ArrayTypes (
+ b = { },
+ s = { },
+ i = { },
+ l = { },
+ c = { },
+ f = { },
+ d = { },
+ bool = { },
+ str = { },
+ cls = { },
+ e = { },
+ a = { }
+ )
+ public void emptyArrayTypesMethod() { }
+
+ @ArrayTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ public void singleElementArrayTypesMethod() { }
+
+ @ArrayTypes (
+ b = { 1, 2 },
+ s = { 2, 3 },
+ i = { 3, 4 },
+ l = { 4L, 5L },
+ c = { '5', '6' },
+ f = { 6.0f, 7.0f },
+ d = { 7.0, 8.0 },
+ bool = { true, false },
+ str = { "custom", "paint" },
+ cls = { Map.class, Set.class },
+ e = { Stooge.MOE, Stooge.CURLY },
+ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
+ )
+ public void twoElementArrayTypesMethod() { }
+
+ @ArrayTypesWithDefault (
+ )
+ public void arrayTypesAcceptDefaultMethod() { }
+
+ @ArrayTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ public void arrayTypesOverrideDefaultMethod() { }
+
+ // Marker
+ @Marker public void markerMethod() { }
+
+ // Single-member (shorthand)
+ @SingleMemberByte(1) public void SingleMemberByte() {}
+ @SingleMemberShort(2) public void SingleMemberShort() {}
+ @SingleMemberInt(3) public void SingleMemberInt() {}
+ @SingleMemberLong(4L) public void SingleMemberLong() {}
+ @SingleMemberChar('5') public void SingleMemberChar() {}
+ @SingleMemberFloat(6.0f) public void SingleMemberFloat() {}
+ @SingleMemberDouble(7.0) public void SingleMemberDouble() {}
+ @SingleMemberBoolean(true) public void SingleMemberBoolean() {}
+ @SingleMemberString("custom") public void SingleMemberString() {}
+ @SingleMemberClass(Map.class) public void SingleMemberClass() {}
+ @SingleMemberEnum(Stooge.MOE) public void SingleMemberEnum() {}
+
+ // Single-member with default (Override)
+ @SingleMemberByteWithDef(1) public void SingleMemberByteOvrdDef() {}
+ @SingleMemberShortWithDef(2) public void SingleMemberShortOvrdDef() {}
+ @SingleMemberIntWithDef(3) public void SingleMemberIntOvrdDef() {}
+ @SingleMemberLongWithDef(4L) public void SingleMemberLongOvrdDef() {}
+ @SingleMemberCharWithDef('5') public void SingleMemberCharOvrdDef() {}
+ @SingleMemberFloatWithDef(6.0f) public void SingleMemberFloatOvrdDef() {}
+ @SingleMemberDoubleWithDef(7.0) public void SingleMemberDoubleOvrdDef() {}
+ @SingleMemberBooleanWithDef(true) public void SingleMemberBooleanOvrdDef() {}
+ @SingleMemberStringWithDef("custom") public void SingleMemberStringOvrdDef() {}
+ @SingleMemberClassWithDef(Map.class) public void SingleMemberClassOvrdDef() {}
+ @SingleMemberEnumWithDef(Stooge.MOE) public void SingleMemberEnumOvrdDef() {}
+
+ // Single-member with default (Accept)
+ @SingleMemberByteWithDef public void SingleMemberByteAcceptDef() {}
+ @SingleMemberShortWithDef public void SingleMemberShortAcceptDef() {}
+ @SingleMemberIntWithDef public void SingleMemberIntAcceptDef() {}
+ @SingleMemberLongWithDef public void SingleMemberLongAcceptDef() {}
+ @SingleMemberCharWithDef public void SingleMemberCharAcceptDef() {}
+ @SingleMemberFloatWithDef public void SingleMemberFloatAcceptDef() {}
+ @SingleMemberDoubleWithDef public void SingleMemberDoubleAcceptDef() {}
+ @SingleMemberBooleanWithDef public void SingleMemberBooleanAcceptDef() {}
+ @SingleMemberStringWithDef public void SingleMemberStringAcceptDef() {}
+ @SingleMemberClassWithDef public void SingleMemberClassAcceptDef() {}
+ @SingleMemberEnumWithDef public void SingleMemberEnumAcceptDef() {}
+
+ // Single member array (empty array)
+ @SingleMemberByteArray({}) public void SingleMemberByteArrEmpty() {}
+ @SingleMemberShortArray({}) public void SingleMemberShortArrEmpty() {}
+ @SingleMemberIntArray({}) public void SingleMemberIntArrEmpty() {}
+ @SingleMemberLongArray({}) public void SingleMemberLongArrEmpty() {}
+ @SingleMemberCharArray({}) public void SingleMemberCharArrEmpty() {}
+ @SingleMemberFloatArray({}) public void SingleMemberFloatArrEmpty() {}
+ @SingleMemberDoubleArray({}) public void SingleMemberDoubleArrEmpty() {}
+ @SingleMemberBooleanArray({})public void SingleMemberBooleanArrEmpty() {}
+ @SingleMemberStringArray({}) public void SingleMemberStringArrEmpty() {}
+ @SingleMemberClassArray({}) public void SingleMemberClassArrEmpty() {}
+ @SingleMemberEnumArray({}) public void SingleMemberEnumArrEmpty() {}
+
+ // Single member array (one-element shorthand)
+ @SingleMemberByteArray(1) public void SingleMemberByteArrOne() {}
+ @SingleMemberShortArray(2) public void SingleMemberShortArrOne() {}
+ @SingleMemberIntArray(3) public void SingleMemberIntArrOne() {}
+ @SingleMemberLongArray(4L) public void SingleMemberLongArrOne() {}
+ @SingleMemberCharArray('5') public void SingleMemberCharArrOne() {}
+ @SingleMemberFloatArray(6.0f) public void SingleMemberFloatArrOne() {}
+ @SingleMemberDoubleArray(7.0) public void SingleMemberDoubleArrOne() {}
+ @SingleMemberBooleanArray(true) public void SingleMemberBooleanArrOne() {}
+ @SingleMemberStringArray("custom") public void SingleMemberStringArrOne() {}
+ @SingleMemberClassArray(Map.class) public void SingleMemberClassArrOne() {}
+ @SingleMemberEnumArray(Stooge.MOE) public void SingleMemberEnumArrOne() {}
+
+ // Single member array (two elements)
+ @SingleMemberByteArray({1, 2}) public void SingleMemberByteArrTwo() {}
+ @SingleMemberShortArray({2, 3}) public void SingleMemberShortArrTwo() {}
+ @SingleMemberIntArray({3, 4}) public void SingleMemberIntArrTwo() {}
+ @SingleMemberLongArray({4L, 5L}) public void SingleMemberLongArrTwo() {}
+ @SingleMemberCharArray({'5', '6'}) public void SingleMemberCharArrTwo() {}
+ @SingleMemberFloatArray({6.0f, 7.0f}) public void SingleMemberFloatArrTwo() {}
+ @SingleMemberDoubleArray({7.0, 8.0}) public void SingleMemberDoubleArrTwo() {}
+ @SingleMemberBooleanArray({true, false}) public void SingleMemberBooleanArrTwo(){}
+ @SingleMemberStringArray({"custom", "paint"}) public void SingleMemberStringArrTwo(){}
+ @SingleMemberClassArray({Map.class, Set.class}) public void SingleMemberClassArrTwo() {}
+ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public void SingleMemberEnumArrTwo() {}
+
+ // Single member array with default (override)
+ @SingleMemberByteArrayDef(1) public void SingleMemberByteArrOvrdDef() {}
+ @SingleMemberShortArrayDef(2) public void SingleMemberShortArrOvrdDef() {}
+ @SingleMemberIntArrayDef(3) public void SingleMemberIntArrOvrdDef() {}
+ @SingleMemberLongArrayDef(4L) public void SingleMemberLongArrOvrdDef() {}
+ @SingleMemberCharArrayDef('5') public void SingleMemberCharArrOvrdDef() {}
+ @SingleMemberFloatArrayDef(6.0f) public void SingleMemberFloatArrOvrdDef() {}
+ @SingleMemberDoubleArrayDef(7.0) public void SingleMemberDoubleArrOvrdDef() {}
+ @SingleMemberBooleanArrayDef(true) public void SingleMemberBooleanArrOvrdDef(){}
+ @SingleMemberStringArrayDef("custom") public void SingleMemberStringArrOvrdDef() {}
+ @SingleMemberClassArrayDef(Map.class) public void SingleMemberClassArrOvrdDef() {}
+ @SingleMemberEnumArrayDef(Stooge.MOE) public void SingleMemberEnumArrOvrdDef() {}
+
+ // Single member array with default - accept
+ @SingleMemberByteArrayDef public void SingleMemberByteArrAcceptDef() {}
+ @SingleMemberShortArrayDef public void SingleMemberShortArrAcceptDef() {}
+ @SingleMemberIntArrayDef public void SingleMemberIntArrAcceptDef() {}
+ @SingleMemberLongArrayDef public void SingleMemberLongArrAcceptDef() {}
+ @SingleMemberCharArrayDef public void SingleMemberCharArrAcceptDef() {}
+ @SingleMemberFloatArrayDef public void SingleMemberFloatArrAcceptDef() {}
+ @SingleMemberDoubleArrayDef public void SingleMemberDoubleArrAcceptDef() {}
+ @SingleMemberBooleanArrayDef public void SingleMemberBooleanArrAcceptDef() {}
+ @SingleMemberStringArrayDef public void SingleMemberStringArrAcceptDef() {}
+ @SingleMemberClassArrayDef public void SingleMemberClassArrAcceptDef() {}
+ @SingleMemberEnumArrayDef public void SingleMemberEnumArrAcceptDef() {}
+
+ // ANNOTATED FIELDS
+ @ScalarTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ public int scalarTypesField;
+
+ @ScalarTypesWithDefault ( )
+ public int scalarTypesAcceptDefaultField;
+
+ @ScalarTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE
+ )
+ public int scalarTypesOverrideDefaultField;
+
+ @ArrayTypes (
+ b = { },
+ s = { },
+ i = { },
+ l = { },
+ c = { },
+ f = { },
+ d = { },
+ bool = { },
+ str = { },
+ cls = { },
+ e = { },
+ a = { }
+ )
+ public int emptyArrayTypesField;
+
+ @ArrayTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ public int singleElementArrayTypesField;
+
+ @ArrayTypes (
+ b = { 1, 2 },
+ s = { 2, 3 },
+ i = { 3, 4 },
+ l = { 4L, 5L },
+ c = { '5', '6' },
+ f = { 6.0f, 7.0f },
+ d = { 7.0, 8.0 },
+ bool = { true, false },
+ str = { "custom", "paint" },
+ cls = { Map.class, Set.class },
+ e = { Stooge.MOE, Stooge.CURLY },
+ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
+ )
+ public int twoElementArrayTypesField;
+
+ @ArrayTypesWithDefault ( )
+ public int arrayTypesAcceptDefaultField;
+
+ @ArrayTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ public int arrayTypesOverrideDefaultField;
+
+ @Marker public int markerField;
+
+ // Single-member (shorthand)
+ @SingleMemberByte(1) public int SingleMemberByteField;
+ @SingleMemberShort(2) public int SingleMemberShortField;
+ @SingleMemberInt(3) public int SingleMemberIntField;
+ @SingleMemberLong(4L) public int SingleMemberLongField;
+ @SingleMemberChar('5') public int SingleMemberCharField;
+ @SingleMemberFloat(6.0f) public int SingleMemberFloatField;
+ @SingleMemberDouble(7.0) public int SingleMemberDoubleField;
+ @SingleMemberBoolean(true) public int SingleMemberBooleanField;
+ @SingleMemberString("custom") public int SingleMemberStringField;
+ @SingleMemberClass(Map.class) public int SingleMemberClassField;
+ @SingleMemberEnum(Stooge.MOE) public int SingleMemberEnumField;
+
+ // Single-member with default (Override)
+ @SingleMemberByteWithDef(1) public int SingleMemberByteOvrdDefField;
+ @SingleMemberShortWithDef(2) public int SingleMemberShortOvrdDefField;
+ @SingleMemberIntWithDef(3) public int SingleMemberIntOvrdDefField;
+ @SingleMemberLongWithDef(4L) public int SingleMemberLongOvrdDefField;
+ @SingleMemberCharWithDef('5') public int SingleMemberCharOvrdDefField;
+ @SingleMemberFloatWithDef(6.0f) public int SingleMemberFloatOvrdDefField;
+ @SingleMemberDoubleWithDef(7.0) public int SingleMemberDoubleOvrdDefField;
+ @SingleMemberBooleanWithDef(true) public int SingleMemberBooleanOvrdDefField;
+ @SingleMemberStringWithDef("custom") public int SingleMemberStringOvrdDefField;
+ @SingleMemberClassWithDef(Map.class) public int SingleMemberClassOvrdDefField;
+ @SingleMemberEnumWithDef(Stooge.MOE) public int SingleMemberEnumOvrdDefField;
+
+ // Single-member with default (Accept)
+ @SingleMemberByteWithDef public int SingleMemberByteAcceptDefField;
+ @SingleMemberShortWithDef public int SingleMemberShortAcceptDefField;
+ @SingleMemberIntWithDef public int SingleMemberIntAcceptDefField;
+ @SingleMemberLongWithDef public int SingleMemberLongAcceptDefField;
+ @SingleMemberCharWithDef public int SingleMemberCharAcceptDefField;
+ @SingleMemberFloatWithDef public int SingleMemberFloatAcceptDefField;
+ @SingleMemberDoubleWithDef public int SingleMemberDoubleAcceptDefField;
+ @SingleMemberBooleanWithDef public int SingleMemberBooleanAcceptDefField;
+ @SingleMemberStringWithDef public int SingleMemberStringAcceptDefField;
+ @SingleMemberClassWithDef public int SingleMemberClassAcceptDefField;
+ @SingleMemberEnumWithDef public int SingleMemberEnumAcceptDefField;
+
+ // Single member array (empty array)
+ @SingleMemberByteArray({}) public int SingleMemberByteArrEmptyField;
+ @SingleMemberShortArray({}) public int SingleMemberShortArrEmptyField;
+ @SingleMemberIntArray({}) public int SingleMemberIntArrEmptyField;
+ @SingleMemberLongArray({}) public int SingleMemberLongArrEmptyField;
+ @SingleMemberCharArray({}) public int SingleMemberCharArrEmptyField;
+ @SingleMemberFloatArray({}) public int SingleMemberFloatArrEmptyField;
+ @SingleMemberDoubleArray({}) public int SingleMemberDoubleArrEmptyField;
+ @SingleMemberBooleanArray({})public int SingleMemberBooleanArrEmptyField;
+ @SingleMemberStringArray({}) public int SingleMemberStringArrEmptyField;
+ @SingleMemberClassArray({}) public int SingleMemberClassArrEmptyField;
+ @SingleMemberEnumArray({}) public int SingleMemberEnumArrEmptyField;
+
+ // Single member array (one-element shorthand)
+ @SingleMemberByteArray(1) public int SingleMemberByteArrOneField;
+ @SingleMemberShortArray(2) public int SingleMemberShortArrOneField;
+ @SingleMemberIntArray(3) public int SingleMemberIntArrOneField;
+ @SingleMemberLongArray(4L) public int SingleMemberLongArrOneField;
+ @SingleMemberCharArray('5') public int SingleMemberCharArrOneField;
+ @SingleMemberFloatArray(6.0f) public int SingleMemberFloatArrOneField;
+ @SingleMemberDoubleArray(7.0) public int SingleMemberDoubleArrOneField;
+ @SingleMemberBooleanArray(true) public int SingleMemberBooleanArrOneField;
+ @SingleMemberStringArray("custom") public int SingleMemberStringArrOneField;
+ @SingleMemberClassArray(Map.class) public int SingleMemberClassArrOneField;
+ @SingleMemberEnumArray(Stooge.MOE) public int SingleMemberEnumArrOneField;
+
+ // Single member array (two elements)
+ @SingleMemberByteArray({1, 2}) public int SingleMemberByteArrTwoField;
+ @SingleMemberShortArray({2, 3}) public int SingleMemberShortArrTwoField;
+ @SingleMemberIntArray({3, 4}) public int SingleMemberIntArrTwoField;
+ @SingleMemberLongArray({4L, 5L}) public int SingleMemberLongArrTwoField;
+ @SingleMemberCharArray({'5', '6'}) public int SingleMemberCharArrTwoField;
+ @SingleMemberFloatArray({6.0f, 7.0f}) public int SingleMemberFloatArrTwoField;
+ @SingleMemberDoubleArray({7.0, 8.0}) public int SingleMemberDoubleArrTwoField;
+ @SingleMemberBooleanArray({true,false}) public int SingleMemberBooleanArrTwoField;
+ @SingleMemberStringArray({"custom", "paint"}) public int SingleMemberStringArrTwoField;
+ @SingleMemberClassArray({Map.class, Set.class}) public int SingleMemberClassArrTwoField;
+ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public int SingleMemberEnumArrTwoField;
+
+ // Single member array with default (override)
+ @SingleMemberByteArrayDef(1) public int SingleMemberByteArrOvrdDefField;
+ @SingleMemberShortArrayDef(2) public int SingleMemberShortArrOvrdDefField;
+ @SingleMemberIntArrayDef(3) public int SingleMemberIntArrOvrdDefField;
+ @SingleMemberLongArrayDef(4L) public int SingleMemberLongArrOvrdDefField;
+ @SingleMemberCharArrayDef('5') public int SingleMemberCharArrOvrdDefField;
+ @SingleMemberFloatArrayDef(6.0f) public int SingleMemberFloatArrOvrdDefField;
+ @SingleMemberDoubleArrayDef(7.0) public int SingleMemberDoubleArrOvrdDefField;
+ @SingleMemberBooleanArrayDef(true) public int SingleMemberBooleanArrOvrdDefField;
+ @SingleMemberStringArrayDef("custom") public int SingleMemberStringArrOvrdDefField;
+ @SingleMemberClassArrayDef(Map.class) public int SingleMemberClassArrOvrdDefField;
+ @SingleMemberEnumArrayDef(Stooge.MOE) public int SingleMemberEnumArrOvrdDefField;
+
+ // Single member array with default - accept
+ @SingleMemberByteArrayDef public int SingleMemberByteArrAcceptDefField;
+ @SingleMemberShortArrayDef public int SingleMemberShortArrAcceptDefField;
+ @SingleMemberIntArrayDef public int SingleMemberIntArrAcceptDefField;
+ @SingleMemberLongArrayDef public int SingleMemberLongArrAcceptDefField;
+ @SingleMemberCharArrayDef public int SingleMemberCharArrAcceptDefField;
+ @SingleMemberFloatArrayDef public int SingleMemberFloatArrAcceptDefField;
+ @SingleMemberDoubleArrayDef public int SingleMemberDoubleArrAcceptDefField;
+ @SingleMemberBooleanArrayDef public int SingleMemberBooleanArrAcceptDefField;
+ @SingleMemberStringArrayDef public int SingleMemberStringArrAcceptDefField;
+ @SingleMemberClassArrayDef public int SingleMemberClassArrAcceptDefField;
+ @SingleMemberEnumArrayDef public int SingleMemberEnumArrAcceptDefField;
+
+ // ANNOTATED ENUM CONSTANTS
+ enum TestType {
+ @ScalarTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ scalarTypesField,
+
+ @ScalarTypesWithDefault ( )
+ scalarTypesAcceptDefaultField,
+
+ @ScalarTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE
+ )
+ scalarTypesOverrideDefaultField,
+
+ @ArrayTypes (
+ b = { },
+ s = { },
+ i = { },
+ l = { },
+ c = { },
+ f = { },
+ d = { },
+ bool = { },
+ str = { },
+ cls = { },
+ e = { },
+ a = { }
+ )
+ emptyArrayTypesField,
+
+ @ArrayTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ singleElementArrayTypesField,
+
+ @ArrayTypes (
+ b = { 1, 2 },
+ s = { 2, 3 },
+ i = { 3, 4 },
+ l = { 4L, 5L },
+ c = { '5', '6' },
+ f = { 6.0f, 7.0f },
+ d = { 7.0, 8.0 },
+ bool = { true, false },
+ str = { "custom", "paint" },
+ cls = { Map.class, Set.class },
+ e = { Stooge.MOE, Stooge.CURLY },
+ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
+ )
+ twoElementArrayTypesField,
+
+ @ArrayTypesWithDefault ( )
+ arrayTypesAcceptDefaultField,
+
+ @ArrayTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ arrayTypesOverrideDefaultField,
+
+ // marker
+ @Marker marker,
+
+ // Single-member (shorthand)
+ @SingleMemberByte(1) SingleMemberByte,
+ @SingleMemberShort(2) SingleMemberShort,
+ @SingleMemberInt(3) SingleMemberInt,
+ @SingleMemberLong(4L) SingleMemberLong,
+ @SingleMemberChar('5') SingleMemberChar,
+ @SingleMemberFloat(6.0f) SingleMemberFloat,
+ @SingleMemberDouble(7.0) SingleMemberDouble,
+ @SingleMemberBoolean(true) SingleMemberBoolean,
+ @SingleMemberString("custom") SingleMemberString,
+ @SingleMemberClass(Map.class) SingleMemberClass,
+ @SingleMemberEnum(Stooge.MOE) SingleMemberEnum,
+
+ // Single-member with default (Override)
+ @SingleMemberByteWithDef(1) SingleMemberByteOvrdDef,
+ @SingleMemberShortWithDef(2) SingleMemberShortOvrdDef,
+ @SingleMemberIntWithDef(3) SingleMemberIntOvrdDef,
+ @SingleMemberLongWithDef(4L) SingleMemberLongOvrdDef,
+ @SingleMemberCharWithDef('5') SingleMemberCharOvrdDef,
+ @SingleMemberFloatWithDef(6.0f) SingleMemberFloatOvrdDef,
+ @SingleMemberDoubleWithDef(7.0) SingleMemberDoubleOvrdDef,
+ @SingleMemberBooleanWithDef(true) SingleMemberBooleanOvrdDef,
+ @SingleMemberStringWithDef("custom") SingleMemberStringOvrdDef,
+ @SingleMemberClassWithDef(Map.class) SingleMemberClassOvrdDef,
+ @SingleMemberEnumWithDef(Stooge.MOE) SingleMemberEnumOvrdDef,
+
+ // Single-member with default (Accept)
+ @SingleMemberByteWithDef SingleMemberByteAcceptDef,
+ @SingleMemberShortWithDef SingleMemberShortAcceptDef,
+ @SingleMemberIntWithDef SingleMemberIntAcceptDef,
+ @SingleMemberLongWithDef SingleMemberLongAcceptDef,
+ @SingleMemberCharWithDef SingleMemberCharAcceptDef,
+ @SingleMemberFloatWithDef SingleMemberFloatAcceptDef,
+ @SingleMemberDoubleWithDef SingleMemberDoubleAcceptDef,
+ @SingleMemberBooleanWithDef SingleMemberBooleanAcceptDef,
+ @SingleMemberStringWithDef SingleMemberStringAcceptDef,
+ @SingleMemberClassWithDef SingleMemberClassAcceptDef,
+ @SingleMemberEnumWithDef SingleMemberEnumAcceptDef,
+
+ // Single member array (empty array)
+ @SingleMemberByteArray({}) SingleMemberByteArrEmpty,
+ @SingleMemberShortArray({}) SingleMemberShortArrEmpty,
+ @SingleMemberIntArray({}) SingleMemberIntArrEmpty,
+ @SingleMemberLongArray({}) SingleMemberLongArrEmpty,
+ @SingleMemberCharArray({}) SingleMemberCharArrEmpty,
+ @SingleMemberFloatArray({}) SingleMemberFloatArrEmpty,
+ @SingleMemberDoubleArray({}) SingleMemberDoubleArrEmpty,
+ @SingleMemberBooleanArray({})SingleMemberBooleanArrEmpty,
+ @SingleMemberStringArray({}) SingleMemberStringArrEmpty,
+ @SingleMemberClassArray({}) SingleMemberClassArrEmpty,
+ @SingleMemberEnumArray({}) SingleMemberEnumArrEmpty,
+
+ // Single member array (one-element shorthand)
+ @SingleMemberByteArray(1) SingleMemberByteArrOne,
+ @SingleMemberShortArray(2) SingleMemberShortArrOne,
+ @SingleMemberIntArray(3) SingleMemberIntArrOne,
+ @SingleMemberLongArray(4L) SingleMemberLongArrOne,
+ @SingleMemberCharArray('5') SingleMemberCharArrOne,
+ @SingleMemberFloatArray(6.0f) SingleMemberFloatArrOne,
+ @SingleMemberDoubleArray(7.0) SingleMemberDoubleArrOne,
+ @SingleMemberBooleanArray(true) SingleMemberBooleanArrOne,
+ @SingleMemberStringArray("custom") SingleMemberStringArrOne,
+ @SingleMemberClassArray(Map.class) SingleMemberClassArrOne,
+ @SingleMemberEnumArray(Stooge.MOE) SingleMemberEnumArrOne,
+
+ // Single member array (two elements)
+ @SingleMemberByteArray({1, 2}) SingleMemberByteArrTwo,
+ @SingleMemberShortArray({2, 3}) SingleMemberShortArrTwo,
+ @SingleMemberIntArray({3, 4}) SingleMemberIntArrTwo,
+ @SingleMemberLongArray({4L, 5L}) SingleMemberLongArrTwo,
+ @SingleMemberCharArray({'5', '6'}) SingleMemberCharArrTwo,
+ @SingleMemberFloatArray({6.0f, 7.0f}) SingleMemberFloatArrTwo,
+ @SingleMemberDoubleArray({7.0, 8.0}) SingleMemberDoubleArrTwo,
+ @SingleMemberBooleanArray({true,false}) SingleMemberBooleanArrTwo,
+ @SingleMemberStringArray({"custom", "paint"}) SingleMemberStringArrTwo,
+ @SingleMemberClassArray({Map.class, Set.class}) SingleMemberClassArrTwo,
+ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) SingleMemberEnumArrTwo,
+
+ // Single member array with default (override)
+ @SingleMemberByteArrayDef(1) SingleMemberByteArrOvrdDef,
+ @SingleMemberShortArrayDef(2) SingleMemberShortArrOvrdDef,
+ @SingleMemberIntArrayDef(3) SingleMemberIntArrOvrdDef,
+ @SingleMemberLongArrayDef(4L) SingleMemberLongArrOvrdDef,
+ @SingleMemberCharArrayDef('5') SingleMemberCharArrOvrdDef,
+ @SingleMemberFloatArrayDef(6.0f) SingleMemberFloatArrOvrdDef,
+ @SingleMemberDoubleArrayDef(7.0) SingleMemberDoubleArrOvrdDef,
+ @SingleMemberBooleanArrayDef(true) SingleMemberBooleanArrOvrdDef,
+ @SingleMemberStringArrayDef("custom") SingleMemberStringArrOvrdDef,
+ @SingleMemberClassArrayDef(Map.class) SingleMemberClassArrOvrdDef,
+ @SingleMemberEnumArrayDef(Stooge.MOE) SingleMemberEnumArrOvrdDef,
+
+ // Single member array with default - accept
+ @SingleMemberByteArrayDef SingleMemberByteArrAcceptDef,
+ @SingleMemberShortArrayDef SingleMemberShortArrAcceptDef,
+ @SingleMemberIntArrayDef SingleMemberIntArrAcceptDef,
+ @SingleMemberLongArrayDef SingleMemberLongArrAcceptDef,
+ @SingleMemberCharArrayDef SingleMemberCharArrAcceptDef,
+ @SingleMemberFloatArrayDef SingleMemberFloatArrAcceptDef,
+ @SingleMemberDoubleArrayDef SingleMemberDoubleArrAcceptDef,
+ @SingleMemberBooleanArrayDef SingleMemberBooleanArrAcceptDef,
+ @SingleMemberStringArrayDef SingleMemberStringArrAcceptDef,
+ @SingleMemberClassArrayDef SingleMemberClassArrAcceptDef,
+ @SingleMemberEnumArrayDef SingleMemberEnumArrAcceptDef,
+ }
+
+ // ANNOTATED CONSTRUCTORS
+
+ @ScalarTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ public UnitTest(Iterator it) { } // scalar types
+
+ @ScalarTypesWithDefault ( )
+ public UnitTest(Set s) { } // scalarTypesAcceptDefault
+
+ @ScalarTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE
+ )
+ public UnitTest(Map s) { } // scalarTypesOverrideDefault
+
+ @ArrayTypes (
+ b = { },
+ s = { },
+ i = { },
+ l = { },
+ c = { },
+ f = { },
+ d = { },
+ bool = { },
+ str = { },
+ cls = { },
+ e = { },
+ a = { }
+ )
+ public UnitTest(List l){ } // emptyArrayTypes
+
+ @ArrayTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ public UnitTest(Collection c) { } // singleElementArrayTypes
+
+ @ArrayTypes (
+ b = { 1, 2 },
+ s = { 2, 3 },
+ i = { 3, 4 },
+ l = { 4L, 5L },
+ c = { '5', '6' },
+ f = { 6.0f, 7.0f },
+ d = { 7.0, 8.0 },
+ bool = { true, false },
+ str = { "custom", "paint" },
+ cls = { Map.class, Set.class },
+ e = { Stooge.MOE, Stooge.CURLY },
+ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
+ )
+ public UnitTest(SortedSet ss) { } // twoElementArrayTypes
+
+ @ArrayTypesWithDefault ( )
+ public UnitTest(SortedMap sm) { } // arrayTypesAcceptDefault
+
+ @ArrayTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ public UnitTest(RandomAccess r) { } // arrayTypesOverrideDefault
+
+ // Marker
+ @Marker public UnitTest() { } // marker
+
+ // Single-member (shorthand)
+ @SingleMemberByte(1) public UnitTest(byte b) { }
+ @SingleMemberShort(2) public UnitTest(short s) { }
+ @SingleMemberInt(3) public UnitTest(int i) { }
+ @SingleMemberLong(4L) public UnitTest(long l) { }
+ @SingleMemberChar('5') public UnitTest(char c) { }
+ @SingleMemberFloat(6.0f) public UnitTest(float f) { }
+ @SingleMemberDouble(7.0) public UnitTest(double d) { }
+ @SingleMemberBoolean(true) public UnitTest(boolean b) { }
+ @SingleMemberString("custom") public UnitTest(String s) { }
+ @SingleMemberClass(Map.class) public UnitTest(Class c) { }
+ @SingleMemberEnum(Stooge.MOE) public UnitTest(Enum e) { }
+
+ // Single-member with default (Override)
+ @SingleMemberByteWithDef(1) public UnitTest(byte b, Set s) { }
+ @SingleMemberShortWithDef(2) public UnitTest(short s, Set x) { }
+ @SingleMemberIntWithDef(3) public UnitTest(int i, Set s) { }
+ @SingleMemberLongWithDef(4L) public UnitTest(long l, Set s) { }
+ @SingleMemberCharWithDef('5') public UnitTest(char c, Set s) { }
+ @SingleMemberFloatWithDef(6.0f) public UnitTest(float f, Set s) { }
+ @SingleMemberDoubleWithDef(7.0) public UnitTest(double d, Set s) { }
+ @SingleMemberBooleanWithDef(true) public UnitTest(boolean b, Set s) { }
+ @SingleMemberStringWithDef("custom") public UnitTest(String s, Set x) { }
+ @SingleMemberClassWithDef(Map.class) public UnitTest(Class c, Set s) { }
+ @SingleMemberEnumWithDef(Stooge.MOE) public UnitTest(Enum e, Set s) { }
+
+ // Single-member with default (Accept)
+ @SingleMemberByteWithDef public UnitTest(byte b, Map m) { }
+ @SingleMemberShortWithDef public UnitTest(short s, Map m) { }
+ @SingleMemberIntWithDef public UnitTest(int i, Map m) { }
+ @SingleMemberLongWithDef public UnitTest(long l, Map m) { }
+ @SingleMemberCharWithDef public UnitTest(char c, Map m) { }
+ @SingleMemberFloatWithDef public UnitTest(float f, Map m) { }
+ @SingleMemberDoubleWithDef public UnitTest(double d, Map m) { }
+ @SingleMemberBooleanWithDef public UnitTest(boolean b, Map m) { }
+ @SingleMemberStringWithDef public UnitTest(String s, Map m) { }
+ @SingleMemberClassWithDef public UnitTest(Class c, Map m) { }
+ @SingleMemberEnumWithDef public UnitTest(Enum e, Map m) { }
+
+ // Single member array (empty array)
+ @SingleMemberByteArray({}) public UnitTest(byte[] b) { }
+ @SingleMemberShortArray({}) public UnitTest(short[] s) { }
+ @SingleMemberIntArray({}) public UnitTest(int[] i) { }
+ @SingleMemberLongArray({}) public UnitTest(long[] l) { }
+ @SingleMemberCharArray({}) public UnitTest(char[] c) { }
+ @SingleMemberFloatArray({}) public UnitTest(float[] f) { }
+ @SingleMemberDoubleArray({}) public UnitTest(double[] d) { }
+ @SingleMemberBooleanArray({})public UnitTest(boolean[] b) { }
+ @SingleMemberStringArray({}) public UnitTest(String[] s) { }
+ @SingleMemberClassArray({}) public UnitTest(Class[] c) { }
+ @SingleMemberEnumArray({}) public UnitTest(Enum[] e) { }
+
+ // Single member array (one-element shorthand)
+ @SingleMemberByteArray(1) public UnitTest(byte[] b, Set s) { }
+ @SingleMemberShortArray(2) public UnitTest(short[] s, Set x) { }
+ @SingleMemberIntArray(3) public UnitTest(int[] i, Set s) { }
+ @SingleMemberLongArray(4L) public UnitTest(long[] l, Set s) { }
+ @SingleMemberCharArray('5') public UnitTest(char[] c, Set s) { }
+ @SingleMemberFloatArray(6.0f) public UnitTest(float[] f, Set s) { }
+ @SingleMemberDoubleArray(7.0) public UnitTest(double[] d, Set s) { }
+ @SingleMemberBooleanArray(true) public UnitTest(boolean[] b, Set s) { }
+ @SingleMemberStringArray("custom") public UnitTest(String[] s, Set x) { }
+ @SingleMemberClassArray(Map.class) public UnitTest(Class[] c, Set s) { }
+ @SingleMemberEnumArray(Stooge.MOE) public UnitTest(Enum[] e, Set s) { }
+
+ // Single member array (two elements)
+ @SingleMemberByteArray({1, 2}) public UnitTest(byte[] b, Map m) { }
+ @SingleMemberShortArray({2, 3}) public UnitTest(short[] s, Map m) { }
+ @SingleMemberIntArray({3, 4}) public UnitTest(int[] i, Map m) { }
+ @SingleMemberLongArray({4L, 5L}) public UnitTest(long[] l, Map m) { }
+ @SingleMemberCharArray({'5', '6'}) public UnitTest(char[] c, Map m) { }
+ @SingleMemberFloatArray({6.0f, 7.0f}) public UnitTest(float[] f, Map m) { }
+ @SingleMemberDoubleArray({7.0, 8.0}) public UnitTest(double[] d, Map m) { }
+ @SingleMemberBooleanArray({true, false}) public UnitTest(boolean[] b, Map m) { }
+ @SingleMemberStringArray({"custom", "paint"}) public UnitTest(String[] s, Map m) { }
+ @SingleMemberClassArray({Map.class,Set.class}) public UnitTest(Class[] c, Map m) { }
+ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public UnitTest(Enum[] e, Map m) { }
+
+
+ // Single member array with default (override)
+ @SingleMemberByteArrayDef(1) public UnitTest(byte[] b, List l) { }
+ @SingleMemberShortArrayDef(2) public UnitTest(short[] s, List l) { }
+ @SingleMemberIntArrayDef(3) public UnitTest(int[] i, List l) { }
+ @SingleMemberLongArrayDef(4L) public UnitTest(long[] l, List x) { }
+ @SingleMemberCharArrayDef('5') public UnitTest(char[] c, List l) { }
+ @SingleMemberFloatArrayDef(6.0f) public UnitTest(float[] f, List l) { }
+ @SingleMemberDoubleArrayDef(7.0) public UnitTest(double[] d, List l) { }
+ @SingleMemberBooleanArrayDef(true) public UnitTest(boolean[] b, List l) { }
+ @SingleMemberStringArrayDef("custom") public UnitTest(String[] s, List l) { }
+ @SingleMemberClassArrayDef(Map.class) public UnitTest(Class[] c, List l) { }
+ @SingleMemberEnumArrayDef(Stooge.MOE) public UnitTest(Enum[] e, List l) { }
+
+ // Single member array with default - accept
+ @SingleMemberByteArrayDef public UnitTest(byte[] b, Collection c) { }
+ @SingleMemberShortArrayDef public UnitTest(short[] s, Collection c) { }
+ @SingleMemberIntArrayDef public UnitTest(int[] i, Collection c) { }
+ @SingleMemberLongArrayDef public UnitTest(long[] l, Collection c) { }
+ @SingleMemberCharArrayDef public UnitTest(char[] c, Collection x) { }
+ @SingleMemberFloatArrayDef public UnitTest(float[] f, Collection c) { }
+ @SingleMemberDoubleArrayDef public UnitTest(double[] d, Collection c) { }
+ @SingleMemberBooleanArrayDef public UnitTest(boolean[] b, Collection c) { }
+ @SingleMemberStringArrayDef public UnitTest(String[] s, Collection c) { }
+ @SingleMemberClassArrayDef public UnitTest(Class[] c, Collection x) { }
+ @SingleMemberEnumArrayDef public UnitTest(Enum[] e, Collection c) { }
+
+ // ANNOTATED PARAMETERS
+
+ public void scalarTypesParam(
+ @ScalarTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ int x) { }
+
+
+ public void scalarTypesAcceptDefaultParam(
+ @ScalarTypesWithDefault int x) { }
+
+ public void scalarTypesOverrideDefaultParam(
+ @ScalarTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE
+ )
+ int x) { }
+
+ public void emptyArrayTypesParam(
+ @ArrayTypes (
+ b = { },
+ s = { },
+ i = { },
+ l = { },
+ c = { },
+ f = { },
+ d = { },
+ bool = { },
+ str = { },
+ cls = { },
+ e = { },
+ a = { }
+ )
+ int x) { }
+
+ public void singleElementArrayTypesParam(
+ @ArrayTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ int x) { }
+
+ public void twoElementArrayTypesParam(
+ @ArrayTypes (
+ b = { 1, 2 },
+ s = { 2, 3 },
+ i = { 3, 4 },
+ l = { 4L, 5L },
+ c = { '5', '6' },
+ f = { 6.0f, 7.0f },
+ d = { 7.0, 8.0 },
+ bool = { true, false },
+ str = { "custom", "paint" },
+ cls = { Map.class, Set.class },
+ e = { Stooge.MOE, Stooge.CURLY },
+ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
+ )
+ int x) { }
+
+ public void arrayTypesAcceptDefaultParam(
+ @ArrayTypesWithDefault
+ int x) { }
+
+ public void arrayTypesOverrideDefaultParam(
+ @ArrayTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ int x) { }
+
+ // Marker
+ public void markerParam(@Marker int x) { }
+
+ // Single-member (shorthand)
+ public void SingleMemberByteParam(@SingleMemberByte(1) int x) {}
+ public void SingleMemberShortParam(@SingleMemberShort(2) int x) {}
+ public void SingleMemberIntParam(@SingleMemberInt(3) int x) {}
+ public void SingleMemberLongParam(@SingleMemberLong(4L) int x) {}
+ public void SingleMemberCharParam(@SingleMemberChar('5') int x) {}
+ public void SingleMemberFloatParam(@SingleMemberFloat(6.0f) int x) {}
+ public void SingleMemberDoubleParam(@SingleMemberDouble(7.0) int x) {}
+ public void SingleMemberBooleanParam(@SingleMemberBoolean(true) int x) {}
+ public void SingleMemberStringParam(@SingleMemberString("custom") int x) {}
+ public void SingleMemberClassParam(@SingleMemberClass(Map.class) int x) {}
+ public void SingleMemberEnumParam(@SingleMemberEnum(Stooge.MOE) int x) {}
+
+ // Single-member with default (Override)
+ public void SingleMemberByteOvrdDefParam(@SingleMemberByteWithDef(1) int x) {}
+ public void SingleMemberShortOvrdDefParam(@SingleMemberShortWithDef(2) int x) {}
+ public void SingleMemberIntOvrdDefParam(@SingleMemberIntWithDef(3) int x) {}
+ public void SingleMemberLongOvrdDefParam(@SingleMemberLongWithDef(4L) int x) {}
+ public void SingleMemberCharOvrdDefParam(@SingleMemberCharWithDef('5') int x) {}
+ public void SingleMemberFloatOvrdDefParam(@SingleMemberFloatWithDef(6.0f) int x) {}
+ public void SingleMemberDoubleOvrdDefParam(@SingleMemberDoubleWithDef(7.0) int x) {}
+ public void SingleMemberBooleanOvrdDefParam(@SingleMemberBooleanWithDef(true) int x) {}
+ public void SingleMemberStringOvrdDefParam(@SingleMemberStringWithDef("custom") int x) {}
+ public void SingleMemberClassOvrdDefParam(@SingleMemberClassWithDef(Map.class) int x) {}
+ public void SingleMemberEnumOvrdDefParam(@SingleMemberEnumWithDef(Stooge.MOE) int x) {}
+
+ // Single-member with default (Accept)
+ public void SingleMemberByteAcceptDefParam(@SingleMemberByteWithDef int x) {}
+ public void SingleMemberShortAcceptDefParam(@SingleMemberShortWithDef int x) {}
+ public void SingleMemberIntAcceptDefParam(@SingleMemberIntWithDef int x) {}
+ public void SingleMemberLongAcceptDefParam(@SingleMemberLongWithDef int x) {}
+ public void SingleMemberCharAcceptDefParam(@SingleMemberCharWithDef int x) {}
+ public void SingleMemberFloatAcceptDefParam(@SingleMemberFloatWithDef int x) {}
+ public void SingleMemberDoubleAcceptDefParam(@SingleMemberDoubleWithDef int x) {}
+ public void SingleMemberBooleanAcceptDefParam(@SingleMemberBooleanWithDef int x){}
+ public void SingleMemberStringAcceptDefParam(@SingleMemberStringWithDef int x) {}
+ public void SingleMemberClassAcceptDefParam(@SingleMemberClassWithDef int x) {}
+ public void SingleMemberEnumAcceptDefParam(@SingleMemberEnumWithDef int x) {}
+
+ // Single member array (empty array)
+ public void SingleMemberByteArrEmptyParam(@SingleMemberByteArray({}) int x) {}
+ public void SingleMemberShortArrEmptyParam(@SingleMemberShortArray({}) int x) {}
+ public void SingleMemberIntArrEmptyParam(@SingleMemberIntArray({}) int x) {}
+ public void SingleMemberLongArrEmptyParam(@SingleMemberLongArray({}) int x) {}
+ public void SingleMemberCharArrEmptyParam(@SingleMemberCharArray({}) int x) {}
+ public void SingleMemberFloatArrEmptyParam(@SingleMemberFloatArray({}) int x) {}
+ public void SingleMemberDoubleArrEmptyParam(@SingleMemberDoubleArray({}) int x) {}
+ public void SingleMemberBooleanArrEmptyParam(@SingleMemberBooleanArray({}) int x) {}
+ public void SingleMemberStringArrEmptyParam(@SingleMemberStringArray({}) int x) {}
+ public void SingleMemberClassArrEmptyParam(@SingleMemberClassArray({}) int x) {}
+ public void SingleMemberEnumArrEmptyParam(@SingleMemberEnumArray({}) int x) {}
+
+ // Single member array (one-element shorthand)
+ public void SingleMemberByteArrOneParam(@SingleMemberByteArray(1) int x) {}
+ public void SingleMemberShortArrOneParam(@SingleMemberShortArray(2) int x) {}
+ public void SingleMemberIntArrOneParam(@SingleMemberIntArray(3) int x) {}
+ public void SingleMemberLongArrOneParam(@SingleMemberLongArray(4L) int x) {}
+ public void SingleMemberCharArrOneParam(@SingleMemberCharArray('5') int x) {}
+ public void SingleMemberFloatArrOneParam(@SingleMemberFloatArray(6.0f) int x) {}
+ public void SingleMemberDoubleArrOneParam(@SingleMemberDoubleArray(7.0) int x) {}
+ public void SingleMemberBooleanArrOneParam(@SingleMemberBooleanArray(true) int x) {}
+ public void SingleMemberStringArrOneParam(@SingleMemberStringArray("custom") int x) {}
+ public void SingleMemberClassArrOneParam(@SingleMemberClassArray(Map.class) int x) {}
+ public void SingleMemberEnumArrOneParam(@SingleMemberEnumArray(Stooge.MOE) int x) {}
+
+ // Single member array (two elements)
+ public void SingleMemberByteArrTwoParam(@SingleMemberByteArray({1, 2}) int x) {}
+ public void SingleMemberShortArrTwoParam(@SingleMemberShortArray({2, 3}) int x) {}
+ public void SingleMemberIntArrTwoParam(@SingleMemberIntArray({3, 4}) int x) {}
+ public void SingleMemberLongArrTwoParam(@SingleMemberLongArray({4L, 5L}) int x) {}
+ public void SingleMemberCharArrTwoParam(@SingleMemberCharArray({'5', '6'}) int x) {}
+ public void SingleMemberFloatArrTwoParam(@SingleMemberFloatArray({6.0f, 7.0f}) int x) {}
+ public void SingleMemberDoubleArrTwoParam(@SingleMemberDoubleArray({7.0, 8.0}) int x) {}
+ public void SingleMemberBooleanArrTwoParam(@SingleMemberBooleanArray({true, false}) int x){}
+ public void SingleMemberStringArrTwoParam(@SingleMemberStringArray({"custom", "paint"}) int x) {}
+ public void SingleMemberClassArrTwoParam(@SingleMemberClassArray({Map.class, Set.class}) int x) {}
+ public void SingleMemberEnumArrTwoParam(@SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) int x) {}
+
+ // Single member array with default (override)
+ public void SingleMemberByteArrOvrdDefParam(@SingleMemberByteArrayDef(1) int x) {}
+ public void SingleMemberShortArrOvrdDefParam(@SingleMemberShortArrayDef(2) int x) {}
+ public void SingleMemberIntArrOvrdDefParam(@SingleMemberIntArrayDef(3) int x) {}
+ public void SingleMemberLongArrOvrdDefParam(@SingleMemberLongArrayDef(4L) int x) {}
+ public void SingleMemberCharArrOvrdDefParam(@SingleMemberCharArrayDef('5') int x) {}
+ public void SingleMemberFloatArrOvrdDefParam(@SingleMemberFloatArrayDef(6.0f) int x) {}
+ public void SingleMemberDoubleArrOvrdDefParam(@SingleMemberDoubleArrayDef(7.0) int x) {}
+ public void SingleMemberBooleanArrOvrdDefParam(@SingleMemberBooleanArrayDef(true) int x){}
+ public void SingleMemberStringArrOvrdDefParam(@SingleMemberStringArrayDef("custom") int x) {}
+ public void SingleMemberClassArrOvrdDefParam(@SingleMemberClassArrayDef(Map.class) int x) {}
+ public void SingleMemberEnumArrOvrdDefParam(@SingleMemberEnumArrayDef(Stooge.MOE) int x) {}
+
+ // Single member array with default - accept
+ public void SingleMemberByteArrAcceptDefParam(@SingleMemberByteArrayDef int x) {}
+ public void SingleMemberShortArrAcceptDefParam(@SingleMemberShortArrayDef int x) {}
+ public void SingleMemberIntArrAcceptDefParam(@SingleMemberIntArrayDef int x) {}
+ public void SingleMemberLongArrAcceptDefParam(@SingleMemberLongArrayDef int x) {}
+ public void SingleMemberCharArrAcceptDefParam(@SingleMemberCharArrayDef int x) {}
+ public void SingleMemberFloatArrAcceptDefParam(@SingleMemberFloatArrayDef int x) {}
+ public void SingleMemberDoubleArrAcceptDefParam(@SingleMemberDoubleArrayDef int x) {}
+ public void SingleMemberBooleanArrAcceptDefParam(@SingleMemberBooleanArrayDef int x){}
+ public void SingleMemberStringArrAcceptDefParam(@SingleMemberStringArrayDef int x) {}
+ public void SingleMemberClassArrAcceptDefParam(@SingleMemberClassArrayDef int x) {}
+ public void SingleMemberEnumArrAcceptDefParam(@SingleMemberEnumArrayDef int x) {}
+}
+
+// Helper types
+
+enum Stooge { LARRY, MOE, CURLY }
+
+@Target({}) @interface Point { int x(); int y(); }
+
+// ANNOTATION TYPES
+
+@Retention(RUNTIME) @interface ScalarTypes {
+ byte b();
+ short s();
+ int i();
+ long l();
+ char c();
+ float f();
+ double d();
+ boolean bool();
+ String str();
+ Class cls();
+ Stooge e();
+ Point a();
+}
+
+@Retention(RUNTIME) @interface ScalarTypesWithDefault {
+ byte b() default 11;
+ short s() default 12;
+ int i() default 13;
+ long l() default 14;
+ char c() default 'V';
+ float f() default 16.0f;
+ double d() default 17.0;
+ boolean bool() default false;
+ String str() default "default";
+ Class cls() default Class.class;
+ Stooge e() default Stooge.LARRY;
+ Point a() default @Point(x = 11, y = 12);
+}
+
+@Retention(RUNTIME) @interface ArrayTypes {
+ byte[] b();
+ short[] s();
+ int[] i();
+ long[] l();
+ char[] c();
+ float[] f();
+ double[] d();
+ boolean[] bool();
+ String[] str();
+ Class[] cls();
+ Stooge[] e();
+ Point[] a();
+}
+
+@Retention(RUNTIME) @interface ArrayTypesWithDefault {
+ byte[] b() default { 11 };
+ short[] s() default { 12 };
+ int[] i() default { 13 };
+ long[] l() default { 14L };
+ char[] c() default { 'V' };
+ float[] f() default { 16.0f };
+ double[] d() default { 17.0 };
+ boolean[] bool() default { false };
+ String[] str() default { "default" };
+ Class[] cls() default { Class.class };
+ Stooge[] e() default { Stooge.LARRY };
+ Point[] a() default { @Point(x = 11, y = 12) };
+}
+
+@Retention(RUNTIME) @interface Marker { }
+
+@Retention(RUNTIME) @interface SingleMemberByte { byte value(); }
+@Retention(RUNTIME) @interface SingleMemberShort { short value(); }
+@Retention(RUNTIME) @interface SingleMemberInt { int value(); }
+@Retention(RUNTIME) @interface SingleMemberLong { long value(); }
+@Retention(RUNTIME) @interface SingleMemberChar { char value(); }
+@Retention(RUNTIME) @interface SingleMemberFloat { float value(); }
+@Retention(RUNTIME) @interface SingleMemberDouble { double value(); }
+@Retention(RUNTIME) @interface SingleMemberBoolean { boolean value(); }
+@Retention(RUNTIME) @interface SingleMemberString { String value(); }
+@Retention(RUNTIME) @interface SingleMemberClass { Class value(); }
+@Retention(RUNTIME) @interface SingleMemberEnum { Stooge value(); }
+
+@Retention(RUNTIME) @interface SingleMemberByteWithDef { byte value() default 11; }
+@Retention(RUNTIME) @interface SingleMemberShortWithDef { short value() default 12; }
+@Retention(RUNTIME) @interface SingleMemberIntWithDef { int value() default 13; }
+@Retention(RUNTIME) @interface SingleMemberLongWithDef { long value() default 14; }
+@Retention(RUNTIME) @interface SingleMemberCharWithDef { char value() default 'V'; }
+@Retention(RUNTIME) @interface SingleMemberFloatWithDef { float value() default 16.0f; }
+@Retention(RUNTIME) @interface SingleMemberDoubleWithDef { double value() default 17.0; }
+@Retention(RUNTIME) @interface SingleMemberBooleanWithDef { boolean value() default false; }
+@Retention(RUNTIME) @interface SingleMemberStringWithDef { String value() default "default"; }
+@Retention(RUNTIME) @interface SingleMemberClassWithDef { Class value() default Class.class; }
+@Retention(RUNTIME) @interface SingleMemberEnumWithDef { Stooge value() default Stooge.LARRY; }
+
+@Retention(RUNTIME) @interface SingleMemberByteArray { byte[] value(); }
+@Retention(RUNTIME) @interface SingleMemberShortArray { short[] value(); }
+@Retention(RUNTIME) @interface SingleMemberIntArray { int[] value(); }
+@Retention(RUNTIME) @interface SingleMemberLongArray { long[] value(); }
+@Retention(RUNTIME) @interface SingleMemberCharArray { char[] value(); }
+@Retention(RUNTIME) @interface SingleMemberFloatArray { float[] value(); }
+@Retention(RUNTIME) @interface SingleMemberDoubleArray { double[] value(); }
+@Retention(RUNTIME) @interface SingleMemberBooleanArray { boolean[] value(); }
+@Retention(RUNTIME) @interface SingleMemberStringArray { String[] value(); }
+@Retention(RUNTIME) @interface SingleMemberClassArray { Class[] value(); }
+@Retention(RUNTIME) @interface SingleMemberEnumArray { Stooge[] value(); }
+
+@Retention(RUNTIME) @interface SingleMemberByteArrayDef { byte[] value() default { 11 }; }
+@Retention(RUNTIME) @interface SingleMemberShortArrayDef { short[] value() default { 12 }; }
+@Retention(RUNTIME) @interface SingleMemberIntArrayDef { int[] value() default { 13 }; }
+@Retention(RUNTIME) @interface SingleMemberLongArrayDef { long[] value() default { 14 }; }
+@Retention(RUNTIME) @interface SingleMemberCharArrayDef { char[] value() default { 'V' }; }
+@Retention(RUNTIME) @interface SingleMemberFloatArrayDef { float[] value() default { 16.0f };}
+@Retention(RUNTIME) @interface SingleMemberDoubleArrayDef { double[] value() default { 17.0 }; }
+@Retention(RUNTIME) @interface SingleMemberBooleanArrayDef { boolean[] value() default { false };}
+@Retention(RUNTIME) @interface SingleMemberStringArrayDef {
+ String[] value() default {"default"};
+}
+@Retention(RUNTIME) @interface SingleMemberClassArrayDef {
+ Class[] value() default {Class.class};
+}
+@Retention(RUNTIME) @interface SingleMemberEnumArrayDef {
+ Stooge[] value() default {Stooge.LARRY};
+}
+
+// Annotation types for inheritance and declared-annotations tests
+@Inherited @Retention(RUNTIME) @interface Foo { }
+ @Retention(RUNTIME) @interface Bar { }
+
+
+ // ANNOTATED CLASSES
+
+ @ScalarTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ class scalarTypesClass { }
+
+ @ScalarTypesWithDefault ( )
+ class scalarTypesAcceptDefaultClass { }
+
+ @ScalarTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE
+ )
+ class scalarTypesOverrideDefaultClass { }
+
+ @ArrayTypes (
+ b = { },
+ s = { },
+ i = { },
+ l = { },
+ c = { },
+ f = { },
+ d = { },
+ bool = { },
+ str = { },
+ cls = { },
+ e = { },
+ a = { }
+ )
+ class emptyArrayTypesClass { }
+
+ @ArrayTypes (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = @Point(x = 1, y = 2)
+ )
+ class singleElementArrayTypesClass { }
+
+ @ArrayTypes (
+ b = { 1, 2 },
+ s = { 2, 3 },
+ i = { 3, 4 },
+ l = { 4L, 5L },
+ c = { '5', '6' },
+ f = { 6.0f, 7.0f },
+ d = { 7.0, 8.0 },
+ bool = { true, false },
+ str = { "custom", "paint" },
+ cls = { Map.class, Set.class },
+ e = { Stooge.MOE, Stooge.CURLY },
+ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
+ )
+ class twoElementArrayTypesClass { }
+
+ @ArrayTypesWithDefault (
+ )
+ class arrayTypesAcceptDefaultClass { }
+
+ @ArrayTypesWithDefault (
+ b = 1,
+ s = 2,
+ i = 3,
+ l = 4L,
+ c = '5',
+ f = 6.0f,
+ d = 7.0,
+ bool = true,
+ str = "custom",
+ cls = Map.class,
+ e = Stooge.MOE,
+ a = { @Point(x = 1, y = 2) }
+ )
+ class arrayTypesOverrideDefaultClass { }
+
+ @Marker class markerClass { }
+
+ // Single-member (shorthand)
+ @SingleMemberByte(1) class SingleMemberByteClass { }
+ @SingleMemberShort(2) class SingleMemberShortClass { }
+ @SingleMemberInt(3) class SingleMemberIntClass { }
+ @SingleMemberLong(4L) class SingleMemberLongClass { }
+ @SingleMemberChar('5') class SingleMemberCharClass { }
+ @SingleMemberFloat(6.0f) class SingleMemberFloatClass { }
+ @SingleMemberDouble(7.0) class SingleMemberDoubleClass { }
+ @SingleMemberBoolean(true) class SingleMemberBooleanClass { }
+ @SingleMemberString("custom") class SingleMemberStringClass { }
+ @SingleMemberClass(Map.class) class SingleMemberClassClass { }
+ @SingleMemberEnum(Stooge.MOE) class SingleMemberEnumClass { }
+
+ // Single-member with default (Override)
+ @SingleMemberByteWithDef(1) class SingleMemberByteOvrdDefClass { }
+ @SingleMemberShortWithDef(2) class SingleMemberShortOvrdDefClass { }
+ @SingleMemberIntWithDef(3) class SingleMemberIntOvrdDefClass { }
+ @SingleMemberLongWithDef(4L) class SingleMemberLongOvrdDefClass { }
+ @SingleMemberCharWithDef('5') class SingleMemberCharOvrdDefClass { }
+ @SingleMemberFloatWithDef(6.0f) class SingleMemberFloatOvrdDefClass { }
+ @SingleMemberDoubleWithDef(7.0) class SingleMemberDoubleOvrdDefClass { }
+ @SingleMemberBooleanWithDef(true) class SingleMemberBooleanOvrdDefClass { }
+ @SingleMemberStringWithDef("custom") class SingleMemberStringOvrdDefClass { }
+ @SingleMemberClassWithDef(Map.class) class SingleMemberClassOvrdDefClass { }
+ @SingleMemberEnumWithDef(Stooge.MOE) class SingleMemberEnumOvrdDefClass { }
+
+ // Single-member with default (Accept)
+ @SingleMemberByteWithDef class SingleMemberByteAcceptDefClass { }
+ @SingleMemberShortWithDef class SingleMemberShortAcceptDefClass { }
+ @SingleMemberIntWithDef class SingleMemberIntAcceptDefClass { }
+ @SingleMemberLongWithDef class SingleMemberLongAcceptDefClass { }
+ @SingleMemberCharWithDef class SingleMemberCharAcceptDefClass { }
+ @SingleMemberFloatWithDef class SingleMemberFloatAcceptDefClass { }
+ @SingleMemberDoubleWithDef class SingleMemberDoubleAcceptDefClass { }
+ @SingleMemberBooleanWithDef class SingleMemberBooleanAcceptDefClass { }
+ @SingleMemberStringWithDef class SingleMemberStringAcceptDefClass { }
+ @SingleMemberClassWithDef class SingleMemberClassAcceptDefClass { }
+ @SingleMemberEnumWithDef class SingleMemberEnumAcceptDefClass { }
+
+ // Single member array (empty array)
+ @SingleMemberByteArray({}) class SingleMemberByteArrEmptyClass { }
+ @SingleMemberShortArray({}) class SingleMemberShortArrEmptyClass { }
+ @SingleMemberIntArray({}) class SingleMemberIntArrEmptyClass { }
+ @SingleMemberLongArray({}) class SingleMemberLongArrEmptyClass { }
+ @SingleMemberCharArray({}) class SingleMemberCharArrEmptyClass { }
+ @SingleMemberFloatArray({}) class SingleMemberFloatArrEmptyClass { }
+ @SingleMemberDoubleArray({}) class SingleMemberDoubleArrEmptyClass { }
+ @SingleMemberBooleanArray({})class SingleMemberBooleanArrEmptyClass { }
+ @SingleMemberStringArray({}) class SingleMemberStringArrEmptyClass { }
+ @SingleMemberClassArray({}) class SingleMemberClassArrEmptyClass { }
+ @SingleMemberEnumArray({}) class SingleMemberEnumArrEmptyClass { }
+
+ // Single member array (one-element shorthand)
+ @SingleMemberByteArray(1) class SingleMemberByteArrOneClass { }
+ @SingleMemberShortArray(2) class SingleMemberShortArrOneClass { }
+ @SingleMemberIntArray(3) class SingleMemberIntArrOneClass { }
+ @SingleMemberLongArray(4L) class SingleMemberLongArrOneClass { }
+ @SingleMemberCharArray('5') class SingleMemberCharArrOneClass { }
+ @SingleMemberFloatArray(6.0f) class SingleMemberFloatArrOneClass { }
+ @SingleMemberDoubleArray(7.0) class SingleMemberDoubleArrOneClass { }
+ @SingleMemberBooleanArray(true) class SingleMemberBooleanArrOneClass { }
+ @SingleMemberStringArray("custom") class SingleMemberStringArrOneClass { }
+ @SingleMemberClassArray(Map.class) class SingleMemberClassArrOneClass { }
+ @SingleMemberEnumArray(Stooge.MOE) class SingleMemberEnumArrOneClass { }
+
+ // Single member array (two elements)
+ @SingleMemberByteArray({1, 2}) class SingleMemberByteArrTwoClass { }
+ @SingleMemberShortArray({2, 3}) class SingleMemberShortArrTwoClass { }
+ @SingleMemberIntArray({3, 4}) class SingleMemberIntArrTwoClass { }
+ @SingleMemberLongArray({4L, 5L}) class SingleMemberLongArrTwoClass { }
+ @SingleMemberCharArray({'5', '6'}) class SingleMemberCharArrTwoClass { }
+ @SingleMemberFloatArray({6.0f, 7.0f}) class SingleMemberFloatArrTwoClass { }
+ @SingleMemberDoubleArray({7.0, 8.0}) class SingleMemberDoubleArrTwoClass { }
+ @SingleMemberBooleanArray({true,false}) class SingleMemberBooleanArrTwoClass { }
+ @SingleMemberStringArray({"custom", "paint"}) class SingleMemberStringArrTwoClass { }
+ @SingleMemberClassArray({Map.class, Set.class}) class SingleMemberClassArrTwoClass { }
+ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) class SingleMemberEnumArrTwoClass { }
+
+ // Single member array with default (override)
+ @SingleMemberByteArrayDef(1) class SingleMemberByteArrOvrdDefClass { }
+ @SingleMemberShortArrayDef(2) class SingleMemberShortArrOvrdDefClass { }
+ @SingleMemberIntArrayDef(3) class SingleMemberIntArrOvrdDefClass { }
+ @SingleMemberLongArrayDef(4L) class SingleMemberLongArrOvrdDefClass { }
+ @SingleMemberCharArrayDef('5') class SingleMemberCharArrOvrdDefClass { }
+ @SingleMemberFloatArrayDef(6.0f) class SingleMemberFloatArrOvrdDefClass { }
+ @SingleMemberDoubleArrayDef(7.0) class SingleMemberDoubleArrOvrdDefClass { }
+ @SingleMemberBooleanArrayDef(true) class SingleMemberBooleanArrOvrdDefClass { }
+ @SingleMemberStringArrayDef("custom") class SingleMemberStringArrOvrdDefClass { }
+ @SingleMemberClassArrayDef(Map.class) class SingleMemberClassArrOvrdDefClass { }
+ @SingleMemberEnumArrayDef(Stooge.MOE) class SingleMemberEnumArrOvrdDefClass { }
+
+ // Single member array with default - accept
+ @SingleMemberByteArrayDef class SingleMemberByteArrAcceptDefClass { }
+ @SingleMemberShortArrayDef class SingleMemberShortArrAcceptDefClass { }
+ @SingleMemberIntArrayDef class SingleMemberIntArrAcceptDefClass { }
+ @SingleMemberLongArrayDef class SingleMemberLongArrAcceptDefClass { }
+ @SingleMemberCharArrayDef class SingleMemberCharArrAcceptDefClass { }
+ @SingleMemberFloatArrayDef class SingleMemberFloatArrAcceptDefClass { }
+ @SingleMemberDoubleArrayDef class SingleMemberDoubleArrAcceptDefClass { }
+ @SingleMemberBooleanArrayDef class SingleMemberBooleanArrAcceptDefClass { }
+ @SingleMemberStringArrayDef class SingleMemberStringArrAcceptDefClass { }
+ @SingleMemberClassArrayDef class SingleMemberClassArrAcceptDefClass { }
+ @SingleMemberEnumArrayDef class SingleMemberEnumArrAcceptDefClass { }
+
+ // Annotated classes for inheritance and declared-annotations tests
+ @Foo @Bar class Grandpa { }
+ class Dad extends Grandpa { }
+ @Bar class Son extends Dad { }