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