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