FYI: Backport newly Freed tests from OpenJDK7
Andrew John Hughes
gnu_andrew at member.fsf.org
Tue Feb 10 18:17:33 PST 2009
A number of additional JTReg tests were Freed for OpenJDK7 b46.
This patch backports them to IcedTea6.
ChangeLog:
2009-02-11 Andrew John Hughes <ahughes at redhat.com>
* Makefile.am:
Add new patches.
* patches/openjdk/bidi-tests.patch,
* patches/openjdk/annotation-tests.patch:
New.
--
Andrew :)
Free Java Software Engineer
Red Hat, Inc. (http://www.redhat.com)
Support Free Java!
Contribute to GNU Classpath and the OpenJDK
http://www.gnu.org/software/classpath
http://openjdk.java.net
PGP Key: 94EFD9D8 (http://subkeys.pgp.net)
Fingerprint = F8EF F1EA 401E 2E60 15FA 7927 142C 2591 94EF D9D8
-------------- next part --------------
diff -r 3b8dcbd3d44d Makefile.am
--- a/Makefile.am Tue Feb 10 16:19:54 2009 -0500
+++ b/Makefile.am Wed Feb 11 02:15:37 2009 +0000
@@ -563,7 +563,9 @@
patches/icedtea-io_util-overflow.patch \
patches/icedtea-cc-interp-jvmti.patch \
patches/icedtea-pr261.patch \
- patches/icedtea-doc-headers.patch
+ patches/icedtea-doc-headers.patch \
+ patches/openjdk/bidi-tests.patch \
+ patches/openjdk/annotation-tests.patch
if WITH_ALT_HSBUILD
ICEDTEA_PATCHES += \
diff -r 3b8dcbd3d44d patches/openjdk/annotation-tests.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/annotation-tests.patch Wed Feb 11 02:15:37 2009 +0000
@@ -0,0 +1,5867 @@
+# HG changeset patch
+# User darcy
+# Date 1233028166 28800
+# Node ID f3ad2ee4600b102d50a18d83aa797e187819e072
+# Parent 175b6adf65b31782480878f5a65044b4c97fd7cf
+6740185: Move java/lang/annotations tests to open
+Reviewed-by: jjg
+
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/AnnotationTypeMismatchException/FoundType.java openjdk/jdk/test/java/lang/annotation/AnnotationTypeMismatchException/FoundType.java
+--- openjdk.orig/jdk/test/java/lang/annotation/AnnotationTypeMismatchException/FoundType.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/AnnotationTypeMismatchException/FoundType.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,44 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 6179014
++ * @summary AnnotationTypeMismatchException.foundType method shouldn't loop.
++ * @author Scott Seligman
++ * @run main/timeout=30 FoundType
++ */
++
++import java.lang.annotation.*;
++
++public class FoundType {
++
++ private static final String TYPE = "a.halting.Problem";
++
++ public static void main(String[] args) {
++ AnnotationTypeMismatchException ex =
++ new AnnotationTypeMismatchException(null, TYPE);
++ if (!TYPE.equals(ex.foundType()))
++ throw new Error();
++ }
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/A.java openjdk/jdk/test/java/lang/annotation/loaderLeak/A.java
+--- openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/A.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/loaderLeak/A.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,28 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++public
++ at java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
++ at interface A {
++ B b();
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/B.java openjdk/jdk/test/java/lang/annotation/loaderLeak/B.java
+--- openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/B.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/loaderLeak/B.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,24 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++public @interface B {}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/C.java openjdk/jdk/test/java/lang/annotation/loaderLeak/C.java
+--- openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/C.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/loaderLeak/C.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,24 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++public @A(b=@B()) class C {}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh openjdk/jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh
+--- openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/loaderLeak/LoaderLeak.sh 2009-02-05 08:45:04.000000000 +0000
+@@ -0,0 +1,84 @@
++#!/bin/sh
++
++# Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++#
++# This code is free software; you can redistribute it and/or modify it
++# under the terms of the GNU General Public License version 2 only, as
++# published by the Free Software Foundation.
++#
++# This code is distributed in the hope that it will be useful, but WITHOUT
++# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++# version 2 for more details (a copy is included in the LICENSE file that
++# accompanied this code).
++#
++# You should have received a copy of the GNU General Public License version
++# 2 along with this work; if not, write to the Free Software Foundation,
++# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++#
++# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++# CA 95054 USA or visit www.sun.com if you need additional information or
++# have any questions.
++
++if [ "${TESTSRC}" = "" ]
++then
++ echo "TESTSRC not set. Test cannot execute. Failed."
++ exit 1
++fi
++echo "TESTSRC=${TESTSRC}"
++if [ "${TESTJAVA}" = "" ]
++then
++ echo "TESTJAVA not set. Test cannot execute. Failed."
++ exit 1
++fi
++echo "TESTJAVA=${TESTJAVA}"
++if [ "${TESTCLASSES}" = "" ]
++then
++ echo "TESTCLASSES not set. Test cannot execute. Failed."
++ exit 1
++fi
++echo "TESTCLASSES=${TESTCLASSES}"
++echo "CLASSPATH=${CLASSPATH}"
++
++# set platform-dependent variables
++OS=`uname -s`
++case "$OS" in
++ SunOS | Linux )
++ NULL=/dev/null
++ PS=":"
++ FS="/"
++ ;;
++ Windows* )
++ NULL=NUL
++ PS=";"
++ FS="\\"
++ ;;
++ * )
++ echo "Unrecognized system!"
++ exit 1;
++ ;;
++esac
++
++mkdir -p classes
++cp ${TESTSRC}${FS}*.java .
++${TESTJAVA}${FS}bin${FS}javac -d classes A.java B.java C.java
++${TESTJAVA}${FS}bin${FS}javac Main.java
++${TESTJAVA}${FS}bin${FS}java Main
++result=$?
++if [ $result -eq 0 ]
++then
++ echo "Passed 1 of 2"
++else
++ echo "Failed 1 of 2"
++ exit $result
++fi
++${TESTJAVA}${FS}bin${FS}java Main foo
++result=$?
++if [ $result -eq 0 ]
++then
++ echo "Passed 2 of 2"
++else
++ echo "Failed 2 of 2"
++fi
++exit $result
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/Main.java openjdk/jdk/test/java/lang/annotation/loaderLeak/Main.java
+--- openjdk.orig/jdk/test/java/lang/annotation/loaderLeak/Main.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/loaderLeak/Main.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,127 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 5040740
++ * @summary annotations cause memory leak
++ * @author gafter
++ *
++ * @run shell LoaderLeak.sh
++ */
++
++import java.net.*;
++import java.lang.ref.*;
++import java.util.*;
++import java.io.*;
++
++public class Main {
++ public static void main(String[] args) throws Exception {
++ for (int i=0; i<100; i++)
++ doTest(args.length != 0);
++ }
++
++ static void doTest(boolean readAnn) throws Exception {
++ // URL classes = new URL("file://" + System.getProperty("user.dir") + "/classes");
++ // URL[] path = { classes };
++ // URLClassLoader loader = new URLClassLoader(path);
++ ClassLoader loader = new SimpleClassLoader();
++ WeakReference<Class<?>> c = new WeakReference(loader.loadClass("C"));
++ if (c.get() == null) throw new AssertionError();
++ if (c.get().getClassLoader() != loader) throw new AssertionError();
++ if (readAnn) System.out.println(c.get().getAnnotations()[0]);
++ if (c.get() == null) throw new AssertionError();
++ System.gc();
++ System.gc();
++ if (c.get() == null) throw new AssertionError();
++ System.gc();
++ System.gc();
++ loader = null;
++ System.gc();
++ System.gc();
++ if (c.get() != null) throw new AssertionError();
++ }
++}
++
++class SimpleClassLoader extends ClassLoader {
++ private Hashtable classes = new Hashtable();
++
++ public SimpleClassLoader() {
++ }
++ private byte getClassImplFromDataBase(String className)[] {
++ byte result[];
++ try {
++ FileInputStream fi = new FileInputStream("classes/"+className+".class");
++ result = new byte[fi.available()];
++ fi.read(result);
++ return result;
++ } catch (Exception e) {
++
++ /*
++ * If we caught an exception, either the class wasnt found or it
++ * was unreadable by our process.
++ */
++ return null;
++ }
++ }
++ public Class loadClass(String className) throws ClassNotFoundException {
++ return (loadClass(className, true));
++ }
++ public synchronized Class loadClass(String className, boolean resolveIt)
++ throws ClassNotFoundException {
++ Class result;
++ byte classData[];
++
++ /* Check our local cache of classes */
++ result = (Class)classes.get(className);
++ if (result != null) {
++ return result;
++ }
++
++ /* Check with the primordial class loader */
++ try {
++ result = super.findSystemClass(className);
++ return result;
++ } catch (ClassNotFoundException e) {
++ }
++
++ /* Try to load it from our repository */
++ classData = getClassImplFromDataBase(className);
++ if (classData == null) {
++ throw new ClassNotFoundException();
++ }
++
++ /* Define it (parse the class file) */
++ result = defineClass(classData, 0, classData.length);
++ if (result == null) {
++ throw new ClassFormatError();
++ }
++
++ if (resolveIt) {
++ resolveClass(result);
++ }
++
++ classes.put(className, result);
++ return result;
++ }
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/A.java openjdk/jdk/test/java/lang/annotation/Missing/A.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/A.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/A.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,30 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/**
++ * Class to have a missing annotation applied for running MissingTest.
++ */
++ at Missing
++ at Marker
++public class A {
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/B.java openjdk/jdk/test/java/lang/annotation/Missing/B.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/B.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/B.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,31 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/**
++ * Class to have an indirectly missing annotation applied for for
++ * running MisssingTest.
++ */
++ at MissingWrapper(@Missing)
++ at Marker
++public class B {
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/C.java openjdk/jdk/test/java/lang/annotation/Missing/C.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/C.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/C.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,31 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/**
++ * Class to have a missing annotation applied for running MissingTest.
++ */
++public class C {
++ public void method1(@Missing @Marker Object param1) {
++ return;
++ }
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/D.java openjdk/jdk/test/java/lang/annotation/Missing/D.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/D.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/D.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,31 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/**
++ * Class to have a missing annotation applied for running MissingTest.
++ */
++public class D {
++ public void method1(@MissingWrapper(@Missing) @Marker Object param1) {
++ return;
++ }
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/Marker.java openjdk/jdk/test/java/lang/annotation/Missing/Marker.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/Marker.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/Marker.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,32 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++import java.lang.annotation.Retention;
++import static java.lang.annotation.RetentionPolicy.*;
++
++/**
++ * A marker annotation. Used so that at least one annotation will be
++ * present on the classes tested by MissingTest.
++ */
++ at Retention(RUNTIME)
++public @interface Marker {}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/Missing.java openjdk/jdk/test/java/lang/annotation/Missing/Missing.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/Missing.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/Missing.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,32 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++import java.lang.annotation.Retention;
++import static java.lang.annotation.RetentionPolicy.*;
++
++/**
++ * The class file for this annotation type is missing when MissingTest
++ * is run.
++ */
++ at Retention(RUNTIME)
++public @interface Missing {}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/MissingTest.java openjdk/jdk/test/java/lang/annotation/Missing/MissingTest.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/MissingTest.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/MissingTest.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,135 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 6322301
++ * @summary Verify when missing annotation classes cause exceptions
++ * @author Joseph D. Darcy
++ * @compile MissingTest.java A.java B.java C.java D.java Marker.java Missing.java MissingWrapper.java
++ * @clean Missing
++ * @run main MissingTest
++ */
++
++import java.lang.reflect.*;
++
++/**
++ * This test verifies that a missing annotation class leads to the
++ * expected exceptional behavior; a missing directly applied
++ * annotation is currently ignored but a missing annotation value
++ * inside another annotation throws an exception.
++ *
++ * To be run as intended, the annotation type Missing should *not* be
++ * on the classpath when the test is run; with jtreg, it is deleted by
++ * the @clean directive.
++ */
++public class MissingTest {
++ /**
++ * For the annotated element argument, get all its annotations and
++ * see whether or not an exception is throw upon reading the
++ * annotations. Additionally, verify at least one annotation is
++ * present.
++ */
++ private static void testAnnotation(AnnotatedElement element,
++ boolean exceptionExpected) {
++ java.lang.annotation.Annotation[] annotations;
++ try {
++ annotations = element.getAnnotations();
++ if (exceptionExpected) {
++ System.err.println("Error: Did not get an exception reading annotations on "
++ + element);
++ System.err.println("Annotations found: "
++ + java.util.Arrays.toString(annotations));
++ throw new RuntimeException();
++ }
++ if (annotations.length == 0) {
++ System.err.println("Error: no annotations found on " + element);
++ throw new RuntimeException();
++ }
++ } catch (Throwable t) {
++ if (!exceptionExpected) {
++ System.err.println("Error: Got an unexpected exception reading annotations on "
++ + element);
++ throw new RuntimeException(t);
++ }
++ }
++ }
++
++ /**
++ * For the annotated element argument, get all its annotations and
++ * see whether or not an exception is throw upon reading the
++ * annotations. Additionally, verify at least one annotation is
++ * present.
++ */
++ private static void testParameterAnnotation(Method m,
++ boolean exceptionExpected) {
++ java.lang.annotation.Annotation[][] annotationsArray;
++ try {
++ annotationsArray = m.getParameterAnnotations();
++ if (exceptionExpected) {
++ System.err.println("Error: Did not get an exception reading annotations on method"
++ + m);
++ System.err.println("Annotations found: "
++ + java.util.Arrays.toString(annotationsArray));
++ throw new RuntimeException();
++ }
++ if (annotationsArray.length == 0 ) {
++ System.err.println("Error: no parameters for " + m);
++ throw new RuntimeException();
++ } else {
++ java.lang.annotation.Annotation[] annotations = annotationsArray[0];
++ if (annotations.length == 0) {
++ System.err.println("Error: no annotations on " + m);
++ throw new RuntimeException();
++ }
++ }
++ } catch (Throwable t) {
++ if (!exceptionExpected) {
++ System.err.println("Error: Got an unexpected exception reading annotations on "
++ + m);
++ throw new RuntimeException(t);
++ }
++ }
++ }
++
++ public static void main(String argv[]) throws Exception {
++ // Class A has a directly applied annotation whose class is
++ // missing.
++ testAnnotation(A.class, false);
++
++ // Class B has a directly applied annotation whose value
++ // includes to an annotation class that is missing.
++ testAnnotation(B.class, true);
++
++
++ // Class C has a directly applied parameter annotation whose
++ // class is missing.
++ testParameterAnnotation(C.class.getDeclaredMethod("method1", Object.class),
++ false);
++
++ // Class D has a directly applied parameter annotation whose value
++ // includes to an annotation class that is missing.
++ testParameterAnnotation(D.class.getDeclaredMethod("method1", Object.class),
++ true);
++ }
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/Missing/MissingWrapper.java openjdk/jdk/test/java/lang/annotation/Missing/MissingWrapper.java
+--- openjdk.orig/jdk/test/java/lang/annotation/Missing/MissingWrapper.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/Missing/MissingWrapper.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,34 @@
++/*
++ * Copyright 2005 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++import java.lang.annotation.Retention;
++import static java.lang.annotation.RetentionPolicy.*;
++
++/**
++ * Annotation wrapper around an annotation whose class will be missing
++ * when MissingTest is run.
++ */
++ at Retention(RUNTIME)
++public @interface MissingWrapper {
++ Missing value();
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/package-info.java openjdk/jdk/test/java/lang/annotation/package-info.java
+--- openjdk.orig/jdk/test/java/lang/annotation/package-info.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/package-info.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,37 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 4901290 5037531
++ * @summary Package annotations
++ * @author gafter
++ *
++ * @compile -source 1.5 package-info.java PackageMain.java
++ * @run main PackageMain
++ */
++
++ at java.lang.annotation.Documented
++package foo.bar;
++
++class Baz {}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/PackageMain.java openjdk/jdk/test/java/lang/annotation/PackageMain.java
+--- openjdk.orig/jdk/test/java/lang/annotation/PackageMain.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/PackageMain.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,36 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++import java.lang.annotation.Documented;
++
++public class PackageMain {
++ public static void main(String[] args) throws Exception {
++ Class<?> c = Class.forName("foo.bar.Baz");
++ System.out.println("c=" + c);
++ System.out.println("cl=" + c.getClassLoader());
++ Package p = c.getPackage();
++ System.out.println("p=" + p);
++ Documented d = p.getAnnotation(Documented.class);
++ if (d == null) throw new Error();
++ }
++}
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/RecursiveAnnotation.java openjdk/jdk/test/java/lang/annotation/RecursiveAnnotation.java
+--- openjdk.orig/jdk/test/java/lang/annotation/RecursiveAnnotation.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/RecursiveAnnotation.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,44 @@
++/*
++ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 5037685
++ * @summary Under certain circumstances, recursive annotations disappeared
++ * @author Josh Bloch
++ */
++
++import java.lang.annotation.*;
++import static java.lang.annotation.RetentionPolicy.*;
++
++ at Rat public class RecursiveAnnotation {
++ public static void main(String[] args) {
++ if (!RecursiveAnnotation.class.isAnnotationPresent(Rat.class))
++ throw new RuntimeException("RecursiveAnnotation");
++
++ if (!Rat.class.isAnnotationPresent(Rat.class))
++ throw new RuntimeException("Rat");
++ }
++}
++
++ at Retention(RUNTIME) @Rat @interface Rat { }
+diff -Nru openjdk.orig/jdk/test/java/lang/annotation/UnitTest.java openjdk/jdk/test/java/lang/annotation/UnitTest.java
+--- openjdk.orig/jdk/test/java/lang/annotation/UnitTest.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/jdk/test/java/lang/annotation/UnitTest.java 2009-02-11 00:58:01.000000000 +0000
+@@ -0,0 +1,4983 @@
++/*
++ * Copyright 2003-2004 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 4906359 4963461 4965058 4965039 4986770
++ * @summary Unit test for annotation reading
++ * @author Josh Bloch
++ * @compile -source 1.5 UnitTest.java
++ * @run main UnitTest
++ */
++
++import static java.lang.annotation.RetentionPolicy.RUNTIME;
++
++import java.lang.annotation.*;
++import java.util.*;
++import java.lang.reflect.*;
++import java.io.*;
++
++public class UnitTest {
++ private static final Class[] X = new Class[0];
++ private static final Class[] Y = { int.class };
++
++ static int numTests = 0;
++
++ public static void main(String[] args) throws Exception {
++
++ // *** TESTS ON ANNOTATED METHODS ***
++
++ // MULTIMEMBER SCALAR TYPES ON METHOD
++ checkScalarTypes(UnitTest.class.getMethod("scalarTypesMethod", X));
++ checkScalarTypesOverrideDefault(UnitTest.class.getMethod("scalarTypesOverrideDefaultMethod", X));
++ checkScalarTypesAcceptDefault(UnitTest.class.getMethod("scalarTypesAcceptDefaultMethod", X));
++
++ // MULTIMEMBER ARRAY TYPES ON METHOD
++ checkArrayTypes0(UnitTest.class.getMethod("emptyArrayTypesMethod", X));
++ checkArrayTypes1(UnitTest.class.getMethod("singleElementArrayTypesMethod", X));
++ checkArrayTypes2(UnitTest.class.getMethod("twoElementArrayTypesMethod", X));
++ checkArrayTypesAcceptDefault(UnitTest.class.getMethod("arrayTypesAcceptDefaultMethod", X));
++ checkArrayTypesOverrideDefault(UnitTest.class.getMethod("arrayTypesOverrideDefaultMethod", X));
++
++ // MARKER TYPE ON METHOD
++ checkMarker(UnitTest.class.getMethod("markerMethod", X));
++
++ // SINGLE-MEMBER SCALAR TYPES ON METHOD
++ checkSingleMemberByte(UnitTest.class.getMethod("SingleMemberByte", X));
++ checkSingleMemberShort(UnitTest.class.getMethod("SingleMemberShort", X));
++ checkSingleMemberInt(UnitTest.class.getMethod("SingleMemberInt", X));
++ checkSingleMemberLong(UnitTest.class.getMethod("SingleMemberLong", X));
++ checkSingleMemberChar(UnitTest.class.getMethod("SingleMemberChar", X));
++ checkSingleMemberFloat(UnitTest.class.getMethod("SingleMemberFloat", X));
++ checkSingleMemberDouble(UnitTest.class.getMethod("SingleMemberDouble", X));
++ checkSingleMemberBoolean(UnitTest.class.getMethod("SingleMemberBoolean", X));
++ checkSingleMemberString(UnitTest.class.getMethod("SingleMemberString", X));
++ checkSingleMemberClass(UnitTest.class.getMethod("SingleMemberClass", X));
++ checkSingleMemberEnum(UnitTest.class.getMethod("SingleMemberEnum", X));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON METHOD
++ checkSingleMemberByteOvrdDef(UnitTest.class.getMethod("SingleMemberByteOvrdDef", X));
++ checkSingleMemberShortOvrdDef(UnitTest.class.getMethod("SingleMemberShortOvrdDef", X));
++ checkSingleMemberIntOvrdDef(UnitTest.class.getMethod("SingleMemberIntOvrdDef", X));
++ checkSingleMemberLongOvrdDef(UnitTest.class.getMethod("SingleMemberLongOvrdDef", X));
++ checkSingleMemberCharOvrdDef(UnitTest.class.getMethod("SingleMemberCharOvrdDef", X));
++ checkSingleMemberFloatOvrdDef(UnitTest.class.getMethod("SingleMemberFloatOvrdDef", X));
++ checkSingleMemberDoubleOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleOvrdDef", X));
++ checkSingleMemberBooleanOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanOvrdDef", X));
++ checkSingleMemberStringOvrdDef(UnitTest.class.getMethod("SingleMemberStringOvrdDef", X));
++ checkSingleMemberClassOvrdDef(UnitTest.class.getMethod("SingleMemberClassOvrdDef", X));
++ checkSingleMemberEnumOvrdDef(UnitTest.class.getMethod("SingleMemberEnumOvrdDef", X));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON METHOD
++ checkSingleMemberByteAcceptDef(UnitTest.class.getMethod("SingleMemberByteAcceptDef", X));
++ checkSingleMemberShortAcceptDef(UnitTest.class.getMethod("SingleMemberShortAcceptDef", X));
++ checkSingleMemberIntAcceptDef(UnitTest.class.getMethod("SingleMemberIntAcceptDef", X));
++ checkSingleMemberLongAcceptDef(UnitTest.class.getMethod("SingleMemberLongAcceptDef", X));
++ checkSingleMemberCharAcceptDef(UnitTest.class.getMethod("SingleMemberCharAcceptDef", X));
++ checkSingleMemberFloatAcceptDef(UnitTest.class.getMethod("SingleMemberFloatAcceptDef", X));
++ checkSingleMemberDoubleAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleAcceptDef", X));
++ checkSingleMemberBooleanAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanAcceptDef", X));
++ checkSingleMemberStringAcceptDef(UnitTest.class.getMethod("SingleMemberStringAcceptDef", X));
++ checkSingleMemberClassAcceptDef(UnitTest.class.getMethod("SingleMemberClassAcceptDef", X));
++ checkSingleMemberEnumAcceptDef(UnitTest.class.getMethod("SingleMemberEnumAcceptDef", X));
++
++ // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON METHOD
++ checkSingleMemberByteArrEmpty(UnitTest.class.getMethod("SingleMemberByteArrEmpty", X));
++ checkSingleMemberShortArrEmpty(UnitTest.class.getMethod("SingleMemberShortArrEmpty", X));
++ checkSingleMemberIntArrEmpty(UnitTest.class.getMethod("SingleMemberIntArrEmpty", X));
++ checkSingleMemberLongArrEmpty(UnitTest.class.getMethod("SingleMemberLongArrEmpty", X));
++ checkSingleMemberCharArrEmpty(UnitTest.class.getMethod("SingleMemberCharArrEmpty", X));
++ checkSingleMemberFloatArrEmpty(UnitTest.class.getMethod("SingleMemberFloatArrEmpty", X));
++ checkSingleMemberDoubleArrEmpty(UnitTest.class.getMethod("SingleMemberDoubleArrEmpty", X));
++ checkSingleMemberBooleanArrEmpty(UnitTest.class.getMethod("SingleMemberBooleanArrEmpty", X));
++ checkSingleMemberStringArrEmpty(UnitTest.class.getMethod("SingleMemberStringArrEmpty", X));
++ checkSingleMemberClassArrEmpty(UnitTest.class.getMethod("SingleMemberClassArrEmpty", X));
++ checkSingleMemberEnumArrEmpty(UnitTest.class.getMethod("SingleMemberEnumArrEmpty", X));
++
++ // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON METHOD
++ checkSingleMemberByteArrOne(UnitTest.class.getMethod("SingleMemberByteArrOne", X));
++ checkSingleMemberShortArrOne(UnitTest.class.getMethod("SingleMemberShortArrOne", X));
++ checkSingleMemberIntArrOne(UnitTest.class.getMethod("SingleMemberIntArrOne", X));
++ checkSingleMemberLongArrOne(UnitTest.class.getMethod("SingleMemberLongArrOne", X));
++ checkSingleMemberCharArrOne(UnitTest.class.getMethod("SingleMemberCharArrOne", X));
++ checkSingleMemberFloatArrOne(UnitTest.class.getMethod("SingleMemberFloatArrOne", X));
++ checkSingleMemberDoubleArrOne(UnitTest.class.getMethod("SingleMemberDoubleArrOne", X));
++ checkSingleMemberBooleanArrOne(UnitTest.class.getMethod("SingleMemberBooleanArrOne", X));
++ checkSingleMemberStringArrOne(UnitTest.class.getMethod("SingleMemberStringArrOne", X));
++ checkSingleMemberClassArrOne(UnitTest.class.getMethod("SingleMemberClassArrOne", X));
++ checkSingleMemberEnumArrOne(UnitTest.class.getMethod("SingleMemberEnumArrOne", X));
++
++ // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON METHOD
++ checkSingleMemberByteArrTwo(UnitTest.class.getMethod("SingleMemberByteArrTwo", X));
++ checkSingleMemberShortArrTwo(UnitTest.class.getMethod("SingleMemberShortArrTwo", X));
++ checkSingleMemberIntArrTwo(UnitTest.class.getMethod("SingleMemberIntArrTwo", X));
++ checkSingleMemberLongArrTwo(UnitTest.class.getMethod("SingleMemberLongArrTwo", X));
++ checkSingleMemberCharArrTwo(UnitTest.class.getMethod("SingleMemberCharArrTwo", X));
++ checkSingleMemberFloatArrTwo(UnitTest.class.getMethod("SingleMemberFloatArrTwo", X));
++ checkSingleMemberDoubleArrTwo(UnitTest.class.getMethod("SingleMemberDoubleArrTwo", X));
++ checkSingleMemberBooleanArrTwo(UnitTest.class.getMethod("SingleMemberBooleanArrTwo", X));
++ checkSingleMemberStringArrTwo(UnitTest.class.getMethod("SingleMemberStringArrTwo", X));
++ checkSingleMemberClassArrTwo(UnitTest.class.getMethod("SingleMemberClassArrTwo", X));
++ checkSingleMemberEnumArrTwo(UnitTest.class.getMethod("SingleMemberEnumArrTwo", X));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON METHOD
++ checkSingleMemberByteArrOvrdDef(UnitTest.class.getMethod("SingleMemberByteArrOvrdDef", X));
++ checkSingleMemberShortArrOvrdDef(UnitTest.class.getMethod("SingleMemberShortArrOvrdDef", X));
++ checkSingleMemberIntArrOvrdDef(UnitTest.class.getMethod("SingleMemberIntArrOvrdDef", X));
++ checkSingleMemberLongArrOvrdDef(UnitTest.class.getMethod("SingleMemberLongArrOvrdDef", X));
++ checkSingleMemberCharArrOvrdDef(UnitTest.class.getMethod("SingleMemberCharArrOvrdDef", X));
++ checkSingleMemberFloatArrOvrdDef(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDef", X));
++ checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDef", X));
++ checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDef", X));
++ checkSingleMemberStringArrOvrdDef(UnitTest.class.getMethod("SingleMemberStringArrOvrdDef", X));
++ checkSingleMemberClassArrOvrdDef(UnitTest.class.getMethod("SingleMemberClassArrOvrdDef", X));
++ checkSingleMemberEnumArrOvrdDef(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDef", X));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON METHOD
++ checkSingleMemberByteArrAcceptDef(UnitTest.class.getMethod("SingleMemberByteArrAcceptDef", X));
++ checkSingleMemberShortArrAcceptDef(UnitTest.class.getMethod("SingleMemberShortArrAcceptDef", X));
++ checkSingleMemberIntArrAcceptDef(UnitTest.class.getMethod("SingleMemberIntArrAcceptDef", X));
++ checkSingleMemberLongArrAcceptDef(UnitTest.class.getMethod("SingleMemberLongArrAcceptDef", X));
++ checkSingleMemberCharArrAcceptDef(UnitTest.class.getMethod("SingleMemberCharArrAcceptDef", X));
++ checkSingleMemberFloatArrAcceptDef(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDef", X));
++ checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDef", X));
++ checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDef", X));
++ checkSingleMemberStringArrAcceptDef(UnitTest.class.getMethod("SingleMemberStringArrAcceptDef", X));
++ checkSingleMemberClassArrAcceptDef(UnitTest.class.getMethod("SingleMemberClassArrAcceptDef", X));
++ checkSingleMemberEnumArrAcceptDef(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDef", X));
++
++ // *** TESTS ON ANNOTATED FIELDS ***
++
++ // MULTIMEMBER SCALAR TYPES ON FIELD
++ checkScalarTypes(UnitTest.class.getField("scalarTypesField"));
++ checkScalarTypesAcceptDefault(UnitTest.class.getField("scalarTypesAcceptDefaultField"));
++ checkScalarTypesOverrideDefault(UnitTest.class.getField("scalarTypesOverrideDefaultField"));
++
++ // MULTIMEMBER ARRAY TYPES ON FIELD
++ checkArrayTypes0(UnitTest.class.getField("emptyArrayTypesField"));
++ checkArrayTypes1(UnitTest.class.getField("singleElementArrayTypesField"));
++ checkArrayTypes2(UnitTest.class.getField("twoElementArrayTypesField"));
++ checkArrayTypesAcceptDefault(UnitTest.class.getField("arrayTypesAcceptDefaultField"));
++ checkArrayTypesOverrideDefault(UnitTest.class.getField("arrayTypesOverrideDefaultField"));
++
++ // MARKER TYPE ON FIELD
++ checkMarker(UnitTest.class.getField("markerField"));
++
++ // SINGLE-MEMBER SCALAR TYPES ON FIELD
++ checkSingleMemberByte(UnitTest.class.getField("SingleMemberByteField"));
++ checkSingleMemberShort(UnitTest.class.getField("SingleMemberShortField"));
++ checkSingleMemberInt(UnitTest.class.getField("SingleMemberIntField"));
++ checkSingleMemberLong(UnitTest.class.getField("SingleMemberLongField"));
++ checkSingleMemberChar(UnitTest.class.getField("SingleMemberCharField"));
++ checkSingleMemberFloat(UnitTest.class.getField("SingleMemberFloatField"));
++ checkSingleMemberDouble(UnitTest.class.getField("SingleMemberDoubleField"));
++ checkSingleMemberBoolean(UnitTest.class.getField("SingleMemberBooleanField"));
++ checkSingleMemberString(UnitTest.class.getField("SingleMemberStringField"));
++ checkSingleMemberClass(UnitTest.class.getField("SingleMemberClassField"));
++ checkSingleMemberEnum(UnitTest.class.getField("SingleMemberEnumField"));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON FIELD
++ checkSingleMemberByteOvrdDef(UnitTest.class.getField("SingleMemberByteOvrdDefField"));
++ checkSingleMemberShortOvrdDef(UnitTest.class.getField("SingleMemberShortOvrdDefField"));
++ checkSingleMemberIntOvrdDef(UnitTest.class.getField("SingleMemberIntOvrdDefField"));
++ checkSingleMemberLongOvrdDef(UnitTest.class.getField("SingleMemberLongOvrdDefField"));
++ checkSingleMemberCharOvrdDef(UnitTest.class.getField("SingleMemberCharOvrdDefField"));
++ checkSingleMemberFloatOvrdDef(UnitTest.class.getField("SingleMemberFloatOvrdDefField"));
++ checkSingleMemberDoubleOvrdDef(UnitTest.class.getField("SingleMemberDoubleOvrdDefField"));
++ checkSingleMemberBooleanOvrdDef(UnitTest.class.getField("SingleMemberBooleanOvrdDefField"));
++ checkSingleMemberStringOvrdDef(UnitTest.class.getField("SingleMemberStringOvrdDefField"));
++ checkSingleMemberClassOvrdDef(UnitTest.class.getField("SingleMemberClassOvrdDefField"));
++ checkSingleMemberEnumOvrdDef(UnitTest.class.getField("SingleMemberEnumOvrdDefField"));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON FIELD
++ checkSingleMemberByteAcceptDef(UnitTest.class.getField("SingleMemberByteAcceptDefField"));
++ checkSingleMemberShortAcceptDef(UnitTest.class.getField("SingleMemberShortAcceptDefField"));
++ checkSingleMemberIntAcceptDef(UnitTest.class.getField("SingleMemberIntAcceptDefField"));
++ checkSingleMemberLongAcceptDef(UnitTest.class.getField("SingleMemberLongAcceptDefField"));
++ checkSingleMemberCharAcceptDef(UnitTest.class.getField("SingleMemberCharAcceptDefField"));
++ checkSingleMemberFloatAcceptDef(UnitTest.class.getField("SingleMemberFloatAcceptDefField"));
++ checkSingleMemberDoubleAcceptDef(UnitTest.class.getField("SingleMemberDoubleAcceptDefField"));
++ checkSingleMemberBooleanAcceptDef(UnitTest.class.getField("SingleMemberBooleanAcceptDefField"));
++ checkSingleMemberStringAcceptDef(UnitTest.class.getField("SingleMemberStringAcceptDefField"));
++ checkSingleMemberClassAcceptDef(UnitTest.class.getField("SingleMemberClassAcceptDefField"));
++ checkSingleMemberEnumAcceptDef(UnitTest.class.getField("SingleMemberEnumAcceptDefField"));
++
++ // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON FIELD
++ checkSingleMemberByteArrEmpty(UnitTest.class.getField("SingleMemberByteArrEmptyField"));
++ checkSingleMemberShortArrEmpty(UnitTest.class.getField("SingleMemberShortArrEmptyField"));
++ checkSingleMemberIntArrEmpty(UnitTest.class.getField("SingleMemberIntArrEmptyField"));
++ checkSingleMemberLongArrEmpty(UnitTest.class.getField("SingleMemberLongArrEmptyField"));
++ checkSingleMemberCharArrEmpty(UnitTest.class.getField("SingleMemberCharArrEmptyField"));
++ checkSingleMemberFloatArrEmpty(UnitTest.class.getField("SingleMemberFloatArrEmptyField"));
++ checkSingleMemberDoubleArrEmpty(UnitTest.class.getField("SingleMemberDoubleArrEmptyField"));
++ checkSingleMemberBooleanArrEmpty(UnitTest.class.getField("SingleMemberBooleanArrEmptyField"));
++ checkSingleMemberStringArrEmpty(UnitTest.class.getField("SingleMemberStringArrEmptyField"));
++ checkSingleMemberClassArrEmpty(UnitTest.class.getField("SingleMemberClassArrEmptyField"));
++ checkSingleMemberEnumArrEmpty(UnitTest.class.getField("SingleMemberEnumArrEmptyField"));
++
++ // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON FIELD
++ checkSingleMemberByteArrOne(UnitTest.class.getField("SingleMemberByteArrOneField"));
++ checkSingleMemberShortArrOne(UnitTest.class.getField("SingleMemberShortArrOneField"));
++ checkSingleMemberIntArrOne(UnitTest.class.getField("SingleMemberIntArrOneField"));
++ checkSingleMemberLongArrOne(UnitTest.class.getField("SingleMemberLongArrOneField"));
++ checkSingleMemberCharArrOne(UnitTest.class.getField("SingleMemberCharArrOneField"));
++ checkSingleMemberFloatArrOne(UnitTest.class.getField("SingleMemberFloatArrOneField"));
++ checkSingleMemberDoubleArrOne(UnitTest.class.getField("SingleMemberDoubleArrOneField"));
++ checkSingleMemberBooleanArrOne(UnitTest.class.getField("SingleMemberBooleanArrOneField"));
++ checkSingleMemberStringArrOne(UnitTest.class.getField("SingleMemberStringArrOneField"));
++ checkSingleMemberClassArrOne(UnitTest.class.getField("SingleMemberClassArrOneField"));
++ checkSingleMemberEnumArrOne(UnitTest.class.getField("SingleMemberEnumArrOneField"));
++
++ // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON FIELD
++ checkSingleMemberByteArrTwo(UnitTest.class.getField("SingleMemberByteArrTwoField"));
++ checkSingleMemberShortArrTwo(UnitTest.class.getField("SingleMemberShortArrTwoField"));
++ checkSingleMemberIntArrTwo(UnitTest.class.getField("SingleMemberIntArrTwoField"));
++ checkSingleMemberLongArrTwo(UnitTest.class.getField("SingleMemberLongArrTwoField"));
++ checkSingleMemberCharArrTwo(UnitTest.class.getField("SingleMemberCharArrTwoField"));
++ checkSingleMemberFloatArrTwo(UnitTest.class.getField("SingleMemberFloatArrTwoField"));
++ checkSingleMemberDoubleArrTwo(UnitTest.class.getField("SingleMemberDoubleArrTwoField"));
++ checkSingleMemberBooleanArrTwo(UnitTest.class.getField("SingleMemberBooleanArrTwoField"));
++ checkSingleMemberStringArrTwo(UnitTest.class.getField("SingleMemberStringArrTwoField"));
++ checkSingleMemberClassArrTwo(UnitTest.class.getField("SingleMemberClassArrTwoField"));
++ checkSingleMemberEnumArrTwo(UnitTest.class.getField("SingleMemberEnumArrTwoField"));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON FIELD
++ checkSingleMemberByteArrOvrdDef(UnitTest.class.getField("SingleMemberByteArrOvrdDefField"));
++ checkSingleMemberShortArrOvrdDef(UnitTest.class.getField("SingleMemberShortArrOvrdDefField"));
++ checkSingleMemberIntArrOvrdDef(UnitTest.class.getField("SingleMemberIntArrOvrdDefField"));
++ checkSingleMemberLongArrOvrdDef(UnitTest.class.getField("SingleMemberLongArrOvrdDefField"));
++ checkSingleMemberCharArrOvrdDef(UnitTest.class.getField("SingleMemberCharArrOvrdDefField"));
++ checkSingleMemberFloatArrOvrdDef(UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"));
++ checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"));
++ checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"));
++ checkSingleMemberStringArrOvrdDef(UnitTest.class.getField("SingleMemberStringArrOvrdDefField"));
++ checkSingleMemberClassArrOvrdDef(UnitTest.class.getField("SingleMemberClassArrOvrdDefField"));
++ checkSingleMemberEnumArrOvrdDef(UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON FIELD
++ checkSingleMemberByteArrAcceptDef(UnitTest.class.getField("SingleMemberByteArrAcceptDefField"));
++ checkSingleMemberShortArrAcceptDef(UnitTest.class.getField("SingleMemberShortArrAcceptDefField"));
++ checkSingleMemberIntArrAcceptDef(UnitTest.class.getField("SingleMemberIntArrAcceptDefField"));
++ checkSingleMemberLongArrAcceptDef(UnitTest.class.getField("SingleMemberLongArrAcceptDefField"));
++ checkSingleMemberCharArrAcceptDef(UnitTest.class.getField("SingleMemberCharArrAcceptDefField"));
++ checkSingleMemberFloatArrAcceptDef(UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"));
++ checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"));
++ checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"));
++ checkSingleMemberStringArrAcceptDef(UnitTest.class.getField("SingleMemberStringArrAcceptDefField"));
++ checkSingleMemberClassArrAcceptDef(UnitTest.class.getField("SingleMemberClassArrAcceptDefField"));
++ checkSingleMemberEnumArrAcceptDef(UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"));
++
++ // *** TESTS ON ANNOTATED ENUM CONSTS ***
++
++ // MULTIMEMBER SCALAR TYPES ON ENUM CONST
++ checkScalarTypes(TestType.class.getField("scalarTypesField"));
++ checkScalarTypesAcceptDefault(TestType.class.getField("scalarTypesAcceptDefaultField"));
++ checkScalarTypesOverrideDefault(TestType.class.getField("scalarTypesOverrideDefaultField"));
++
++ // MULTIMEMBER ARRAY TYPES ON ENUM CONST
++ checkArrayTypes0(TestType.class.getField("emptyArrayTypesField"));
++ checkArrayTypes1(TestType.class.getField("singleElementArrayTypesField"));
++ checkArrayTypes2(TestType.class.getField("twoElementArrayTypesField"));
++ checkArrayTypesAcceptDefault(TestType.class.getField("arrayTypesAcceptDefaultField"));
++ checkArrayTypesOverrideDefault(TestType.class.getField("arrayTypesOverrideDefaultField"));
++
++ // MARKER TYPE ON CLASS
++ checkMarker(TestType.class.getField("marker"));
++
++ // SINGLE-MEMBER SCALAR TYPES ON CLASS
++ checkSingleMemberByte(TestType.class.getField("SingleMemberByte"));
++ checkSingleMemberShort(TestType.class.getField("SingleMemberShort"));
++ checkSingleMemberInt(TestType.class.getField("SingleMemberInt"));
++ checkSingleMemberLong(TestType.class.getField("SingleMemberLong"));
++ checkSingleMemberChar(TestType.class.getField("SingleMemberChar"));
++ checkSingleMemberFloat(TestType.class.getField("SingleMemberFloat"));
++ checkSingleMemberDouble(TestType.class.getField("SingleMemberDouble"));
++ checkSingleMemberBoolean(TestType.class.getField("SingleMemberBoolean"));
++ checkSingleMemberString(TestType.class.getField("SingleMemberString"));
++ checkSingleMemberClass(TestType.class.getField("SingleMemberClass"));
++ checkSingleMemberEnum(TestType.class.getField("SingleMemberEnum"));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS
++ checkSingleMemberByteOvrdDef(TestType.class.getField("SingleMemberByteOvrdDef"));
++ checkSingleMemberShortOvrdDef(TestType.class.getField("SingleMemberShortOvrdDef"));
++ checkSingleMemberIntOvrdDef(TestType.class.getField("SingleMemberIntOvrdDef"));
++ checkSingleMemberLongOvrdDef(TestType.class.getField("SingleMemberLongOvrdDef"));
++ checkSingleMemberCharOvrdDef(TestType.class.getField("SingleMemberCharOvrdDef"));
++ checkSingleMemberFloatOvrdDef(TestType.class.getField("SingleMemberFloatOvrdDef"));
++ checkSingleMemberDoubleOvrdDef(TestType.class.getField("SingleMemberDoubleOvrdDef"));
++ checkSingleMemberBooleanOvrdDef(TestType.class.getField("SingleMemberBooleanOvrdDef"));
++ checkSingleMemberStringOvrdDef(TestType.class.getField("SingleMemberStringOvrdDef"));
++ checkSingleMemberClassOvrdDef(TestType.class.getField("SingleMemberClassOvrdDef"));
++ checkSingleMemberEnumOvrdDef(TestType.class.getField("SingleMemberEnumOvrdDef"));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS
++ checkSingleMemberByteAcceptDef(TestType.class.getField("SingleMemberByteAcceptDef"));
++ checkSingleMemberShortAcceptDef(TestType.class.getField("SingleMemberShortAcceptDef"));
++ checkSingleMemberIntAcceptDef(TestType.class.getField("SingleMemberIntAcceptDef"));
++ checkSingleMemberLongAcceptDef(TestType.class.getField("SingleMemberLongAcceptDef"));
++ checkSingleMemberCharAcceptDef(TestType.class.getField("SingleMemberCharAcceptDef"));
++ checkSingleMemberFloatAcceptDef(TestType.class.getField("SingleMemberFloatAcceptDef"));
++ checkSingleMemberDoubleAcceptDef(TestType.class.getField("SingleMemberDoubleAcceptDef"));
++ checkSingleMemberBooleanAcceptDef(TestType.class.getField("SingleMemberBooleanAcceptDef"));
++ checkSingleMemberStringAcceptDef(TestType.class.getField("SingleMemberStringAcceptDef"));
++ checkSingleMemberClassAcceptDef(TestType.class.getField("SingleMemberClassAcceptDef"));
++ checkSingleMemberEnumAcceptDef(TestType.class.getField("SingleMemberEnumAcceptDef"));
++
++ // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("EMPTY ARRAY) ON CLASS
++ checkSingleMemberByteArrEmpty(TestType.class.getField("SingleMemberByteArrEmpty"));
++ checkSingleMemberShortArrEmpty(TestType.class.getField("SingleMemberShortArrEmpty"));
++ checkSingleMemberIntArrEmpty(TestType.class.getField("SingleMemberIntArrEmpty"));
++ checkSingleMemberLongArrEmpty(TestType.class.getField("SingleMemberLongArrEmpty"));
++ checkSingleMemberCharArrEmpty(TestType.class.getField("SingleMemberCharArrEmpty"));
++ checkSingleMemberFloatArrEmpty(TestType.class.getField("SingleMemberFloatArrEmpty"));
++ checkSingleMemberDoubleArrEmpty(TestType.class.getField("SingleMemberDoubleArrEmpty"));
++ checkSingleMemberBooleanArrEmpty(TestType.class.getField("SingleMemberBooleanArrEmpty"));
++ checkSingleMemberStringArrEmpty(TestType.class.getField("SingleMemberStringArrEmpty"));
++ checkSingleMemberClassArrEmpty(TestType.class.getField("SingleMemberClassArrEmpty"));
++ checkSingleMemberEnumArrEmpty(TestType.class.getField("SingleMemberEnumArrEmpty"));
++
++ // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("ONE-ELEMENT ARRAY) ON CLASS
++ checkSingleMemberByteArrOne(TestType.class.getField("SingleMemberByteArrOne"));
++ checkSingleMemberShortArrOne(TestType.class.getField("SingleMemberShortArrOne"));
++ checkSingleMemberIntArrOne(TestType.class.getField("SingleMemberIntArrOne"));
++ checkSingleMemberLongArrOne(TestType.class.getField("SingleMemberLongArrOne"));
++ checkSingleMemberCharArrOne(TestType.class.getField("SingleMemberCharArrOne"));
++ checkSingleMemberFloatArrOne(TestType.class.getField("SingleMemberFloatArrOne"));
++ checkSingleMemberDoubleArrOne(TestType.class.getField("SingleMemberDoubleArrOne"));
++ checkSingleMemberBooleanArrOne(TestType.class.getField("SingleMemberBooleanArrOne"));
++ checkSingleMemberStringArrOne(TestType.class.getField("SingleMemberStringArrOne"));
++ checkSingleMemberClassArrOne(TestType.class.getField("SingleMemberClassArrOne"));
++ checkSingleMemberEnumArrOne(TestType.class.getField("SingleMemberEnumArrOne"));
++
++ // SINGLE-MEMBER ARRAY TYPES (TestType.class.getField("TWO-ELEMENT ARRAY) ON CLASS
++ checkSingleMemberByteArrTwo(TestType.class.getField("SingleMemberByteArrTwo"));
++ checkSingleMemberShortArrTwo(TestType.class.getField("SingleMemberShortArrTwo"));
++ checkSingleMemberIntArrTwo(TestType.class.getField("SingleMemberIntArrTwo"));
++ checkSingleMemberLongArrTwo(TestType.class.getField("SingleMemberLongArrTwo"));
++ checkSingleMemberCharArrTwo(TestType.class.getField("SingleMemberCharArrTwo"));
++ checkSingleMemberFloatArrTwo(TestType.class.getField("SingleMemberFloatArrTwo"));
++ checkSingleMemberDoubleArrTwo(TestType.class.getField("SingleMemberDoubleArrTwo"));
++ checkSingleMemberBooleanArrTwo(TestType.class.getField("SingleMemberBooleanArrTwo"));
++ checkSingleMemberStringArrTwo(TestType.class.getField("SingleMemberStringArrTwo"));
++ checkSingleMemberClassArrTwo(TestType.class.getField("SingleMemberClassArrTwo"));
++ checkSingleMemberEnumArrTwo(TestType.class.getField("SingleMemberEnumArrTwo"));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("OVERRIDE)ON CLASS
++ checkSingleMemberByteArrOvrdDef(TestType.class.getField("SingleMemberByteArrOvrdDef"));
++ checkSingleMemberShortArrOvrdDef(TestType.class.getField("SingleMemberShortArrOvrdDef"));
++ checkSingleMemberIntArrOvrdDef(TestType.class.getField("SingleMemberIntArrOvrdDef"));
++ checkSingleMemberLongArrOvrdDef(TestType.class.getField("SingleMemberLongArrOvrdDef"));
++ checkSingleMemberCharArrOvrdDef(TestType.class.getField("SingleMemberCharArrOvrdDef"));
++ checkSingleMemberFloatArrOvrdDef(TestType.class.getField("SingleMemberFloatArrOvrdDef"));
++ checkSingleMemberDoubleArrOvrdDef(TestType.class.getField("SingleMemberDoubleArrOvrdDef"));
++ checkSingleMemberBooleanArrOvrdDef(TestType.class.getField("SingleMemberBooleanArrOvrdDef"));
++ checkSingleMemberStringArrOvrdDef(TestType.class.getField("SingleMemberStringArrOvrdDef"));
++ checkSingleMemberClassArrOvrdDef(TestType.class.getField("SingleMemberClassArrOvrdDef"));
++ checkSingleMemberEnumArrOvrdDef(TestType.class.getField("SingleMemberEnumArrOvrdDef"));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (TestType.class.getField("ACCEPT)ON CLASS
++ checkSingleMemberByteArrAcceptDef(TestType.class.getField("SingleMemberByteArrAcceptDef"));
++ checkSingleMemberShortArrAcceptDef(TestType.class.getField("SingleMemberShortArrAcceptDef"));
++ checkSingleMemberIntArrAcceptDef(TestType.class.getField("SingleMemberIntArrAcceptDef"));
++ checkSingleMemberLongArrAcceptDef(TestType.class.getField("SingleMemberLongArrAcceptDef"));
++ checkSingleMemberCharArrAcceptDef(TestType.class.getField("SingleMemberCharArrAcceptDef"));
++ checkSingleMemberFloatArrAcceptDef(TestType.class.getField("SingleMemberFloatArrAcceptDef"));
++ checkSingleMemberDoubleArrAcceptDef(TestType.class.getField("SingleMemberDoubleArrAcceptDef"));
++ checkSingleMemberBooleanArrAcceptDef(TestType.class.getField("SingleMemberBooleanArrAcceptDef"));
++ checkSingleMemberStringArrAcceptDef(TestType.class.getField("SingleMemberStringArrAcceptDef"));
++ checkSingleMemberClassArrAcceptDef(TestType.class.getField("SingleMemberClassArrAcceptDef"));
++ checkSingleMemberEnumArrAcceptDef(TestType.class.getField("SingleMemberEnumArrAcceptDef"));
++
++ // *** TESTS ON ANNOTATED CONSTRUCTORS ***
++
++ // MULTIMEMBER SCALAR TYPES ON CONSTRUCTOR
++ checkScalarTypes(UnitTest.class.getConstructor(new Class[]{Iterator.class}));
++ checkScalarTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{Map.class}));
++ checkScalarTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{Set.class}));
++
++ // MULTIMEMBER ARRAY TYPES ON CONSTRUCTOR
++ checkArrayTypes0(UnitTest.class.getConstructor(new Class[]{List.class}));
++ checkArrayTypes1(UnitTest.class.getConstructor(new Class[]{Collection.class}));
++ checkArrayTypes2(UnitTest.class.getConstructor(new Class[]{SortedSet.class}));
++ checkArrayTypesAcceptDefault(UnitTest.class.getConstructor(new Class[]{SortedMap.class}));
++ checkArrayTypesOverrideDefault(UnitTest.class.getConstructor(new Class[]{RandomAccess.class}));
++
++ // MARKER TYPE ON CONSTRUCTOR
++ checkMarker(UnitTest.class.getConstructor(new Class[] { }));
++
++ // SINGLE-MEMBER SCALAR TYPES ON CONSTRUCTOR
++ checkSingleMemberByte(UnitTest.class.getConstructor(new Class[] { byte.class }));
++ checkSingleMemberShort(UnitTest.class.getConstructor(new Class[] { short.class }));
++ checkSingleMemberInt(UnitTest.class.getConstructor(new Class[] { int.class }));
++ checkSingleMemberLong(UnitTest.class.getConstructor(new Class[] { long.class }));
++ checkSingleMemberChar(UnitTest.class.getConstructor(new Class[] { char.class }));
++ checkSingleMemberFloat(UnitTest.class.getConstructor(new Class[] { float.class }));
++ checkSingleMemberDouble(UnitTest.class.getConstructor(new Class[] { double.class }));
++ checkSingleMemberBoolean(UnitTest.class.getConstructor(new Class[] { boolean.class }));
++ checkSingleMemberString(UnitTest.class.getConstructor(new Class[] { String.class }));
++ checkSingleMemberClass(UnitTest.class.getConstructor(new Class[] { Class.class }));
++ checkSingleMemberEnum(UnitTest.class.getConstructor(new Class[] { Enum.class }));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CONSTRUCTOR
++ checkSingleMemberByteOvrdDef(UnitTest.class.getConstructor(new Class[] { byte.class, Set.class }));
++ checkSingleMemberShortOvrdDef(UnitTest.class.getConstructor(new Class[] { short.class, Set.class }));
++ checkSingleMemberIntOvrdDef(UnitTest.class.getConstructor(new Class[] { int.class, Set.class }));
++ checkSingleMemberLongOvrdDef(UnitTest.class.getConstructor(new Class[] { long.class, Set.class }));
++ checkSingleMemberCharOvrdDef(UnitTest.class.getConstructor(new Class[] { char.class, Set.class }));
++ checkSingleMemberFloatOvrdDef(UnitTest.class.getConstructor(new Class[] { float.class, Set.class }));
++ checkSingleMemberDoubleOvrdDef(UnitTest.class.getConstructor(new Class[] { double.class, Set.class }));
++ checkSingleMemberBooleanOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Set.class }));
++ checkSingleMemberStringOvrdDef(UnitTest.class.getConstructor(new Class[] { String.class, Set.class }));
++ checkSingleMemberClassOvrdDef(UnitTest.class.getConstructor(new Class[] { Class.class, Set.class }));
++ checkSingleMemberEnumOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Set.class }));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CONSTRUCTOR
++ checkSingleMemberByteAcceptDef(UnitTest.class.getConstructor(new Class[] { byte.class, Map.class }));
++ checkSingleMemberShortAcceptDef(UnitTest.class.getConstructor(new Class[] { short.class, Map.class }));
++ checkSingleMemberIntAcceptDef(UnitTest.class.getConstructor(new Class[] { int.class, Map.class }));
++ checkSingleMemberLongAcceptDef(UnitTest.class.getConstructor(new Class[] { long.class, Map.class }));
++ checkSingleMemberCharAcceptDef(UnitTest.class.getConstructor(new Class[] { char.class, Map.class }));
++ checkSingleMemberFloatAcceptDef(UnitTest.class.getConstructor(new Class[] { float.class, Map.class }));
++ checkSingleMemberDoubleAcceptDef(UnitTest.class.getConstructor(new Class[] { double.class, Map.class }));
++ checkSingleMemberBooleanAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean.class, Map.class }));
++ checkSingleMemberStringAcceptDef(UnitTest.class.getConstructor(new Class[] { String.class, Map.class }));
++ checkSingleMemberClassAcceptDef(UnitTest.class.getConstructor(new Class[] { Class.class, Map.class }));
++ checkSingleMemberEnumAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum.class, Map.class }));
++
++ // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CONSTRUCTOR
++ checkSingleMemberByteArrEmpty(UnitTest.class.getConstructor(new Class[] { byte[].class }));
++ checkSingleMemberShortArrEmpty(UnitTest.class.getConstructor(new Class[] { short[].class }));
++ checkSingleMemberIntArrEmpty(UnitTest.class.getConstructor(new Class[] { int[].class }));
++ checkSingleMemberLongArrEmpty(UnitTest.class.getConstructor(new Class[] { long[].class }));
++ checkSingleMemberCharArrEmpty(UnitTest.class.getConstructor(new Class[] { char[].class }));
++ checkSingleMemberFloatArrEmpty(UnitTest.class.getConstructor(new Class[] { float[].class }));
++ checkSingleMemberDoubleArrEmpty(UnitTest.class.getConstructor(new Class[] { double[].class }));
++ checkSingleMemberBooleanArrEmpty(UnitTest.class.getConstructor(new Class[] { boolean[].class }));
++ checkSingleMemberStringArrEmpty(UnitTest.class.getConstructor(new Class[] { String[].class }));
++ checkSingleMemberClassArrEmpty(UnitTest.class.getConstructor(new Class[] { Class[].class }));
++ checkSingleMemberEnumArrEmpty(UnitTest.class.getConstructor(new Class[] { Enum[].class }));
++
++ // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CONSTRUCTOR
++ checkSingleMemberByteArrOne(UnitTest.class.getConstructor(new Class[] { byte[].class, Set.class }));
++ checkSingleMemberShortArrOne(UnitTest.class.getConstructor(new Class[] { short[].class, Set.class }));
++ checkSingleMemberIntArrOne(UnitTest.class.getConstructor(new Class[] { int[].class, Set.class }));
++ checkSingleMemberLongArrOne(UnitTest.class.getConstructor(new Class[] { long[].class, Set.class }));
++ checkSingleMemberCharArrOne(UnitTest.class.getConstructor(new Class[] { char[].class, Set.class }));
++ checkSingleMemberFloatArrOne(UnitTest.class.getConstructor(new Class[] { float[].class, Set.class }));
++ checkSingleMemberDoubleArrOne(UnitTest.class.getConstructor(new Class[] { double[].class, Set.class }));
++ checkSingleMemberBooleanArrOne(UnitTest.class.getConstructor(new Class[] { boolean[].class, Set.class }));
++ checkSingleMemberStringArrOne(UnitTest.class.getConstructor(new Class[] { String[].class, Set.class }));
++ checkSingleMemberClassArrOne(UnitTest.class.getConstructor(new Class[] { Class[].class, Set.class }));
++ checkSingleMemberEnumArrOne(UnitTest.class.getConstructor(new Class[] { Enum[].class, Set.class }));
++
++ // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CONSTRUCTOR
++ checkSingleMemberByteArrTwo(UnitTest.class.getConstructor(new Class[] { byte[].class, Map.class }));
++ checkSingleMemberShortArrTwo(UnitTest.class.getConstructor(new Class[] { short[].class, Map.class }));
++ checkSingleMemberIntArrTwo(UnitTest.class.getConstructor(new Class[] { int[].class, Map.class }));
++ checkSingleMemberLongArrTwo(UnitTest.class.getConstructor(new Class[] { long[].class, Map.class }));
++ checkSingleMemberCharArrTwo(UnitTest.class.getConstructor(new Class[] { char[].class, Map.class }));
++ checkSingleMemberFloatArrTwo(UnitTest.class.getConstructor(new Class[] { float[].class, Map.class }));
++ checkSingleMemberDoubleArrTwo(UnitTest.class.getConstructor(new Class[] { double[].class, Map.class }));
++ checkSingleMemberBooleanArrTwo(UnitTest.class.getConstructor(new Class[] { boolean[].class, Map.class }));
++ checkSingleMemberStringArrTwo(UnitTest.class.getConstructor(new Class[] { String[].class, Map.class }));
++ checkSingleMemberClassArrTwo(UnitTest.class.getConstructor(new Class[] { Class[].class, Map.class }));
++ checkSingleMemberEnumArrTwo(UnitTest.class.getConstructor(new Class[] { Enum[].class, Map.class }));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CONSTRUCTOR
++ checkSingleMemberByteArrOvrdDef(UnitTest.class.getConstructor(new Class[] { byte[].class, List.class }));
++ checkSingleMemberShortArrOvrdDef(UnitTest.class.getConstructor(new Class[] { short[].class, List.class }));
++ checkSingleMemberIntArrOvrdDef(UnitTest.class.getConstructor(new Class[] { int[].class, List.class }));
++ checkSingleMemberLongArrOvrdDef(UnitTest.class.getConstructor(new Class[] { long[].class, List.class }));
++ checkSingleMemberCharArrOvrdDef(UnitTest.class.getConstructor(new Class[] { char[].class, List.class }));
++ checkSingleMemberFloatArrOvrdDef(UnitTest.class.getConstructor(new Class[] { float[].class, List.class }));
++ checkSingleMemberDoubleArrOvrdDef(UnitTest.class.getConstructor(new Class[] { double[].class, List.class }));
++ checkSingleMemberBooleanArrOvrdDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, List.class }));
++ checkSingleMemberStringArrOvrdDef(UnitTest.class.getConstructor(new Class[] { String[].class, List.class }));
++ checkSingleMemberClassArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Class[].class, List.class }));
++ checkSingleMemberEnumArrOvrdDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, List.class }));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CONSTRUCTOR
++ checkSingleMemberByteArrAcceptDef(UnitTest.class.getConstructor(new Class[] { byte[].class, Collection.class }));
++ checkSingleMemberShortArrAcceptDef(UnitTest.class.getConstructor(new Class[] { short[].class, Collection.class }));
++ checkSingleMemberIntArrAcceptDef(UnitTest.class.getConstructor(new Class[] { int[].class, Collection.class }));
++ checkSingleMemberLongArrAcceptDef(UnitTest.class.getConstructor(new Class[] { long[].class, Collection.class }));
++ checkSingleMemberCharArrAcceptDef(UnitTest.class.getConstructor(new Class[] { char[].class, Collection.class }));
++ checkSingleMemberFloatArrAcceptDef(UnitTest.class.getConstructor(new Class[] { float[].class, Collection.class }));
++ checkSingleMemberDoubleArrAcceptDef(UnitTest.class.getConstructor(new Class[] { double[].class, Collection.class }));
++ checkSingleMemberBooleanArrAcceptDef(UnitTest.class.getConstructor(new Class[] { boolean[].class, Collection.class }));
++ checkSingleMemberStringArrAcceptDef(UnitTest.class.getConstructor(new Class[] { String[].class, Collection.class }));
++ checkSingleMemberClassArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Class[].class, Collection.class }));
++ checkSingleMemberEnumArrAcceptDef(UnitTest.class.getConstructor(new Class[] { Enum[].class, Collection.class }));
++
++ // *** TESTS ON ANNOTATED PARAMETERS ***
++
++ // MULTIMEMBER SCALAR TYPES ON PARAM
++ checkScalarTypesParam(UnitTest.class.getMethod("scalarTypesParam", Y));
++ checkScalarTypesOverrideDefaultParam(UnitTest.class.getMethod("scalarTypesOverrideDefaultParam", Y));
++ checkScalarTypesAcceptDefaultParam(UnitTest.class.getMethod("scalarTypesAcceptDefaultParam", Y));
++
++ // MULTIMEMBER ARRAY TYPES ON PARAM
++ checkArrayTypes0Param(UnitTest.class.getMethod("emptyArrayTypesParam", Y));
++ checkArrayTypes1Param(UnitTest.class.getMethod("singleElementArrayTypesParam", Y));
++ checkArrayTypes2Param(UnitTest.class.getMethod("twoElementArrayTypesParam", Y));
++ checkArrayTypesAcceptDefaultParam(UnitTest.class.getMethod("arrayTypesAcceptDefaultParam", Y));
++ checkArrayTypesOverrideDefaultParam(UnitTest.class.getMethod("arrayTypesOverrideDefaultParam", Y));
++
++ // MARKER TYPE ON PARAMETER
++ checkMarkerParam(UnitTest.class.getMethod("markerParam", Y));
++
++ // SINGLE-MEMBER SCALAR TYPES ON PARAMETER
++ checkSingleMemberByteParam(UnitTest.class.getMethod("SingleMemberByteParam", Y));
++ checkSingleMemberShortParam(UnitTest.class.getMethod("SingleMemberShortParam", Y));
++ checkSingleMemberIntParam(UnitTest.class.getMethod("SingleMemberIntParam", Y));
++ checkSingleMemberLongParam(UnitTest.class.getMethod("SingleMemberLongParam", Y));
++ checkSingleMemberCharParam(UnitTest.class.getMethod("SingleMemberCharParam", Y));
++ checkSingleMemberFloatParam(UnitTest.class.getMethod("SingleMemberFloatParam", Y));
++ checkSingleMemberDoubleParam(UnitTest.class.getMethod("SingleMemberDoubleParam", Y));
++ checkSingleMemberBooleanParam(UnitTest.class.getMethod("SingleMemberBooleanParam", Y));
++ checkSingleMemberStringParam(UnitTest.class.getMethod("SingleMemberStringParam", Y));
++ checkSingleMemberClassParam(UnitTest.class.getMethod("SingleMemberClassParam", Y));
++ checkSingleMemberEnumParam(UnitTest.class.getMethod("SingleMemberEnumParam", Y));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON PARAMETER
++ checkSingleMemberByteOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteOvrdDefParam", Y));
++ checkSingleMemberShortOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortOvrdDefParam", Y));
++ checkSingleMemberIntOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntOvrdDefParam", Y));
++ checkSingleMemberLongOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongOvrdDefParam", Y));
++ checkSingleMemberCharOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharOvrdDefParam", Y));
++ checkSingleMemberFloatOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatOvrdDefParam", Y));
++ checkSingleMemberDoubleOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleOvrdDefParam", Y));
++ checkSingleMemberBooleanOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanOvrdDefParam", Y));
++ checkSingleMemberStringOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringOvrdDefParam", Y));
++ checkSingleMemberClassOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassOvrdDefParam", Y));
++ checkSingleMemberEnumOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumOvrdDefParam", Y));
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON PARAMETER
++ checkSingleMemberByteAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteAcceptDefParam", Y));
++ checkSingleMemberShortAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortAcceptDefParam", Y));
++ checkSingleMemberIntAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntAcceptDefParam", Y));
++ checkSingleMemberLongAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongAcceptDefParam", Y));
++ checkSingleMemberCharAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharAcceptDefParam", Y));
++ checkSingleMemberFloatAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatAcceptDefParam", Y));
++ checkSingleMemberDoubleAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleAcceptDefParam", Y));
++ checkSingleMemberBooleanAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanAcceptDefParam", Y));
++ checkSingleMemberStringAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringAcceptDefParam", Y));
++ checkSingleMemberClassAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassAcceptDefParam", Y));
++ checkSingleMemberEnumAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumAcceptDefParam", Y));
++
++ // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("EMPTY ARRAY) ON PARAMETER
++ checkSingleMemberByteArrEmptyParam(UnitTest.class.getMethod("SingleMemberByteArrEmptyParam", Y));
++ checkSingleMemberShortArrEmptyParam(UnitTest.class.getMethod("SingleMemberShortArrEmptyParam", Y));
++ checkSingleMemberIntArrEmptyParam(UnitTest.class.getMethod("SingleMemberIntArrEmptyParam", Y));
++ checkSingleMemberLongArrEmptyParam(UnitTest.class.getMethod("SingleMemberLongArrEmptyParam", Y));
++ checkSingleMemberCharArrEmptyParam(UnitTest.class.getMethod("SingleMemberCharArrEmptyParam", Y));
++ checkSingleMemberFloatArrEmptyParam(UnitTest.class.getMethod("SingleMemberFloatArrEmptyParam", Y));
++ checkSingleMemberDoubleArrEmptyParam(UnitTest.class.getMethod("SingleMemberDoubleArrEmptyParam", Y));
++ checkSingleMemberBooleanArrEmptyParam(UnitTest.class.getMethod("SingleMemberBooleanArrEmptyParam", Y));
++ checkSingleMemberStringArrEmptyParam(UnitTest.class.getMethod("SingleMemberStringArrEmptyParam", Y));
++ checkSingleMemberClassArrEmptyParam(UnitTest.class.getMethod("SingleMemberClassArrEmptyParam", Y));
++ checkSingleMemberEnumArrEmptyParam(UnitTest.class.getMethod("SingleMemberEnumArrEmptyParam", Y));
++
++ // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("ONE-ELEMENT ARRAY) ON PARAMETER
++ checkSingleMemberByteArrOneParam(UnitTest.class.getMethod("SingleMemberByteArrOneParam", Y));
++ checkSingleMemberShortArrOneParam(UnitTest.class.getMethod("SingleMemberShortArrOneParam", Y));
++ checkSingleMemberIntArrOneParam(UnitTest.class.getMethod("SingleMemberIntArrOneParam", Y));
++ checkSingleMemberLongArrOneParam(UnitTest.class.getMethod("SingleMemberLongArrOneParam", Y));
++ checkSingleMemberCharArrOneParam(UnitTest.class.getMethod("SingleMemberCharArrOneParam", Y));
++ checkSingleMemberFloatArrOneParam(UnitTest.class.getMethod("SingleMemberFloatArrOneParam", Y));
++ checkSingleMemberDoubleArrOneParam(UnitTest.class.getMethod("SingleMemberDoubleArrOneParam", Y));
++ checkSingleMemberBooleanArrOneParam(UnitTest.class.getMethod("SingleMemberBooleanArrOneParam", Y));
++ checkSingleMemberStringArrOneParam(UnitTest.class.getMethod("SingleMemberStringArrOneParam", Y));
++ checkSingleMemberClassArrOneParam(UnitTest.class.getMethod("SingleMemberClassArrOneParam", Y));
++ checkSingleMemberEnumArrOneParam(UnitTest.class.getMethod("SingleMemberEnumArrOneParam", Y));
++
++ // SINGLE-MEMBER ARRAY TYPES Param(UnitTest.class.getMethod("TWO-ELEMENT ARRAY) ON PARAMETER
++ checkSingleMemberByteArrTwoParam(UnitTest.class.getMethod("SingleMemberByteArrTwoParam", Y));
++ checkSingleMemberShortArrTwoParam(UnitTest.class.getMethod("SingleMemberShortArrTwoParam", Y));
++ checkSingleMemberIntArrTwoParam(UnitTest.class.getMethod("SingleMemberIntArrTwoParam", Y));
++ checkSingleMemberLongArrTwoParam(UnitTest.class.getMethod("SingleMemberLongArrTwoParam", Y));
++ checkSingleMemberCharArrTwoParam(UnitTest.class.getMethod("SingleMemberCharArrTwoParam", Y));
++ checkSingleMemberFloatArrTwoParam(UnitTest.class.getMethod("SingleMemberFloatArrTwoParam", Y));
++ checkSingleMemberDoubleArrTwoParam(UnitTest.class.getMethod("SingleMemberDoubleArrTwoParam", Y));
++ checkSingleMemberBooleanArrTwoParam(UnitTest.class.getMethod("SingleMemberBooleanArrTwoParam", Y));
++ checkSingleMemberStringArrTwoParam(UnitTest.class.getMethod("SingleMemberStringArrTwoParam", Y));
++ checkSingleMemberClassArrTwoParam(UnitTest.class.getMethod("SingleMemberClassArrTwoParam", Y));
++ checkSingleMemberEnumArrTwoParam(UnitTest.class.getMethod("SingleMemberEnumArrTwoParam", Y));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("OVERRIDE)ON PARAMETER
++ checkSingleMemberByteArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberByteArrOvrdDefParam", Y));
++ checkSingleMemberShortArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberShortArrOvrdDefParam", Y));
++ checkSingleMemberIntArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberIntArrOvrdDefParam", Y));
++ checkSingleMemberLongArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberLongArrOvrdDefParam", Y));
++ checkSingleMemberCharArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberCharArrOvrdDefParam", Y));
++ checkSingleMemberFloatArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberFloatArrOvrdDefParam", Y));
++ checkSingleMemberDoubleArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrOvrdDefParam", Y));
++ checkSingleMemberBooleanArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrOvrdDefParam", Y));
++ checkSingleMemberStringArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberStringArrOvrdDefParam", Y));
++ checkSingleMemberClassArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberClassArrOvrdDefParam", Y));
++ checkSingleMemberEnumArrOvrdDefParam(UnitTest.class.getMethod("SingleMemberEnumArrOvrdDefParam", Y));
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT Param(UnitTest.class.getMethod("ACCEPT)ON PARAMETER
++ checkSingleMemberByteArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberByteArrAcceptDefParam", Y));
++ checkSingleMemberShortArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberShortArrAcceptDefParam", Y));
++ checkSingleMemberIntArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberIntArrAcceptDefParam", Y));
++ checkSingleMemberLongArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberLongArrAcceptDefParam", Y));
++ checkSingleMemberCharArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberCharArrAcceptDefParam", Y));
++ checkSingleMemberFloatArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberFloatArrAcceptDefParam", Y));
++ checkSingleMemberDoubleArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberDoubleArrAcceptDefParam", Y));
++ checkSingleMemberBooleanArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberBooleanArrAcceptDefParam", Y));
++ checkSingleMemberStringArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberStringArrAcceptDefParam", Y));
++ checkSingleMemberClassArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberClassArrAcceptDefParam", Y));
++ checkSingleMemberEnumArrAcceptDefParam(UnitTest.class.getMethod("SingleMemberEnumArrAcceptDefParam", Y));
++
++ // *** TESTS ON ANNOTATED CLASSES ***
++
++ // MULTIMEMBER SCALAR TYPES ON CLASS
++ checkScalarTypes(scalarTypesClass.class);
++ checkScalarTypesOverrideDefault(scalarTypesOverrideDefaultClass.class);
++ checkScalarTypesAcceptDefault(scalarTypesAcceptDefaultClass.class);
++
++ // MULTIMEMBER ARRAY TYPES ON CLASS
++ checkArrayTypes0(emptyArrayTypesClass.class);
++ checkArrayTypes1(singleElementArrayTypesClass.class);
++ checkArrayTypes2(twoElementArrayTypesClass.class);
++ checkArrayTypesOverrideDefault(arrayTypesOverrideDefaultClass.class);
++ checkArrayTypesAcceptDefault(arrayTypesAcceptDefaultClass.class);
++
++ // MARKER TYPE ON CLASS
++ checkMarker(markerClass.class);
++
++ // SINGLE-MEMBER SCALAR TYPES ON CLASS
++ checkSingleMemberByte(SingleMemberByteClass.class);
++ checkSingleMemberShort(SingleMemberShortClass.class);
++ checkSingleMemberInt(SingleMemberIntClass.class);
++ checkSingleMemberLong(SingleMemberLongClass.class);
++ checkSingleMemberChar(SingleMemberCharClass.class);
++ checkSingleMemberFloat(SingleMemberFloatClass.class);
++ checkSingleMemberDouble(SingleMemberDoubleClass.class);
++ checkSingleMemberBoolean(SingleMemberBooleanClass.class);
++ checkSingleMemberString(SingleMemberStringClass.class);
++ checkSingleMemberClass(SingleMemberClassClass.class);
++ checkSingleMemberEnum(SingleMemberEnumClass.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE ON CLASS
++ checkSingleMemberByteOvrdDef(SingleMemberByteOvrdDefClass.class);
++ checkSingleMemberShortOvrdDef(SingleMemberShortOvrdDefClass.class);
++ checkSingleMemberIntOvrdDef(SingleMemberIntOvrdDefClass.class);
++ checkSingleMemberLongOvrdDef(SingleMemberLongOvrdDefClass.class);
++ checkSingleMemberCharOvrdDef(SingleMemberCharOvrdDefClass.class);
++ checkSingleMemberFloatOvrdDef(SingleMemberFloatOvrdDefClass.class);
++ checkSingleMemberDoubleOvrdDef(SingleMemberDoubleOvrdDefClass.class);
++ checkSingleMemberBooleanOvrdDef(SingleMemberBooleanOvrdDefClass.class);
++ checkSingleMemberStringOvrdDef(SingleMemberStringOvrdDefClass.class);
++ checkSingleMemberClassOvrdDef(SingleMemberClassOvrdDefClass.class);
++ checkSingleMemberEnumOvrdDef(SingleMemberEnumOvrdDefClass.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT ON CLASS
++ checkSingleMemberByteAcceptDef(SingleMemberByteAcceptDefClass.class);
++ checkSingleMemberShortAcceptDef(SingleMemberShortAcceptDefClass.class);
++ checkSingleMemberIntAcceptDef(SingleMemberIntAcceptDefClass.class);
++ checkSingleMemberLongAcceptDef(SingleMemberLongAcceptDefClass.class);
++ checkSingleMemberCharAcceptDef(SingleMemberCharAcceptDefClass.class);
++ checkSingleMemberFloatAcceptDef(SingleMemberFloatAcceptDefClass.class);
++ checkSingleMemberDoubleAcceptDef(SingleMemberDoubleAcceptDefClass.class);
++ checkSingleMemberBooleanAcceptDef(SingleMemberBooleanAcceptDefClass.class);
++ checkSingleMemberStringAcceptDef(SingleMemberStringAcceptDefClass.class);
++ checkSingleMemberClassAcceptDef(SingleMemberClassAcceptDefClass.class);
++ checkSingleMemberEnumAcceptDef(SingleMemberEnumAcceptDefClass.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY) ON CLASS
++ checkSingleMemberByteArrEmpty(SingleMemberByteArrEmptyClass.class);
++ checkSingleMemberShortArrEmpty(SingleMemberShortArrEmptyClass.class);
++ checkSingleMemberIntArrEmpty(SingleMemberIntArrEmptyClass.class);
++ checkSingleMemberLongArrEmpty(SingleMemberLongArrEmptyClass.class);
++ checkSingleMemberCharArrEmpty(SingleMemberCharArrEmptyClass.class);
++ checkSingleMemberFloatArrEmpty(SingleMemberFloatArrEmptyClass.class);
++ checkSingleMemberDoubleArrEmpty(SingleMemberDoubleArrEmptyClass.class);
++ checkSingleMemberBooleanArrEmpty(SingleMemberBooleanArrEmptyClass.class);
++ checkSingleMemberStringArrEmpty(SingleMemberStringArrEmptyClass.class);
++ checkSingleMemberClassArrEmpty(SingleMemberClassArrEmptyClass.class);
++ checkSingleMemberEnumArrEmpty(SingleMemberEnumArrEmptyClass.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY) ON CLASS
++ checkSingleMemberByteArrOne(SingleMemberByteArrOneClass.class);
++ checkSingleMemberShortArrOne(SingleMemberShortArrOneClass.class);
++ checkSingleMemberIntArrOne(SingleMemberIntArrOneClass.class);
++ checkSingleMemberLongArrOne(SingleMemberLongArrOneClass.class);
++ checkSingleMemberCharArrOne(SingleMemberCharArrOneClass.class);
++ checkSingleMemberFloatArrOne(SingleMemberFloatArrOneClass.class);
++ checkSingleMemberDoubleArrOne(SingleMemberDoubleArrOneClass.class);
++ checkSingleMemberBooleanArrOne(SingleMemberBooleanArrOneClass.class);
++ checkSingleMemberStringArrOne(SingleMemberStringArrOneClass.class);
++ checkSingleMemberClassArrOne(SingleMemberClassArrOneClass.class);
++ checkSingleMemberEnumArrOne(SingleMemberEnumArrOneClass.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY) ON CLASS
++ checkSingleMemberByteArrTwo(SingleMemberByteArrTwoClass.class);
++ checkSingleMemberShortArrTwo(SingleMemberShortArrTwoClass.class);
++ checkSingleMemberIntArrTwo(SingleMemberIntArrTwoClass.class);
++ checkSingleMemberLongArrTwo(SingleMemberLongArrTwoClass.class);
++ checkSingleMemberCharArrTwo(SingleMemberCharArrTwoClass.class);
++ checkSingleMemberFloatArrTwo(SingleMemberFloatArrTwoClass.class);
++ checkSingleMemberDoubleArrTwo(SingleMemberDoubleArrTwoClass.class);
++ checkSingleMemberBooleanArrTwo(SingleMemberBooleanArrTwoClass.class);
++ checkSingleMemberStringArrTwo(SingleMemberStringArrTwoClass.class);
++ checkSingleMemberClassArrTwo(SingleMemberClassArrTwoClass.class);
++ checkSingleMemberEnumArrTwo(SingleMemberEnumArrTwoClass.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)ON CLASS
++ checkSingleMemberByteArrOvrdDef(SingleMemberByteArrOvrdDefClass.class);
++ checkSingleMemberShortArrOvrdDef(SingleMemberShortArrOvrdDefClass.class);
++ checkSingleMemberIntArrOvrdDef(SingleMemberIntArrOvrdDefClass.class);
++ checkSingleMemberLongArrOvrdDef(SingleMemberLongArrOvrdDefClass.class);
++ checkSingleMemberCharArrOvrdDef(SingleMemberCharArrOvrdDefClass.class);
++ checkSingleMemberFloatArrOvrdDef(SingleMemberFloatArrOvrdDefClass.class);
++ checkSingleMemberDoubleArrOvrdDef(SingleMemberDoubleArrOvrdDefClass.class);
++ checkSingleMemberBooleanArrOvrdDef(SingleMemberBooleanArrOvrdDefClass.class);
++ checkSingleMemberStringArrOvrdDef(SingleMemberStringArrOvrdDefClass.class);
++ checkSingleMemberClassArrOvrdDef(SingleMemberClassArrOvrdDefClass.class);
++ checkSingleMemberEnumArrOvrdDef(SingleMemberEnumArrOvrdDefClass.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)ON CLASS
++ checkSingleMemberByteArrAcceptDef(SingleMemberByteArrAcceptDefClass.class);
++ checkSingleMemberShortArrAcceptDef(SingleMemberShortArrAcceptDefClass.class);
++ checkSingleMemberIntArrAcceptDef(SingleMemberIntArrAcceptDefClass.class);
++ checkSingleMemberLongArrAcceptDef(SingleMemberLongArrAcceptDefClass.class);
++ checkSingleMemberCharArrAcceptDef(SingleMemberCharArrAcceptDefClass.class);
++ checkSingleMemberFloatArrAcceptDef(SingleMemberFloatArrAcceptDefClass.class);
++ checkSingleMemberDoubleArrAcceptDef(SingleMemberDoubleArrAcceptDefClass.class);
++ checkSingleMemberBooleanArrAcceptDef(SingleMemberBooleanArrAcceptDefClass.class);
++ checkSingleMemberStringArrAcceptDef(SingleMemberStringArrAcceptDefClass.class);
++ checkSingleMemberClassArrAcceptDef(SingleMemberClassArrAcceptDefClass.class);
++ checkSingleMemberEnumArrAcceptDef(SingleMemberEnumArrAcceptDefClass.class);
++
++ // *** TESTS FOR EQUALS AND HASHCODE - POSITIVE
++
++ // MULTIMEMBER SCALAR TYPES
++ checkEquals(scalarTypesClass.class, UnitTest.class.getField("scalarTypesField"),
++ ScalarTypes.class);
++ checkEquals(scalarTypesOverrideDefaultClass.class, UnitTest.class.getField("scalarTypesOverrideDefaultField"),
++ ScalarTypesWithDefault.class);
++ checkEquals(scalarTypesAcceptDefaultClass.class, UnitTest.class.getField("scalarTypesAcceptDefaultField"),
++ ScalarTypesWithDefault.class);
++
++ // MULTIMEMBER ARRAY TYPES
++ checkEquals(emptyArrayTypesClass.class, UnitTest.class.getField("emptyArrayTypesField"),
++ ArrayTypes.class);
++ checkEquals(singleElementArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"),
++ ArrayTypes.class);
++ checkEquals(twoElementArrayTypesClass.class, UnitTest.class.getField("twoElementArrayTypesField"),
++ ArrayTypes.class);
++ checkEquals(arrayTypesOverrideDefaultClass.class, UnitTest.class.getField("arrayTypesOverrideDefaultField"),
++ ArrayTypesWithDefault.class);
++ checkEquals(arrayTypesAcceptDefaultClass.class, UnitTest.class.getField("arrayTypesAcceptDefaultField"),
++ ArrayTypesWithDefault.class);
++
++ // MARKER TYPE
++ checkEquals(markerClass.class, UnitTest.class.getField("markerField"),
++ Marker.class);
++
++ // SINGLE-MEMBER SCALAR TYPES
++ checkEquals(SingleMemberByteClass.class, UnitTest.class.getField("SingleMemberByteField"),
++ SingleMemberByte.class);
++ checkEquals(SingleMemberShortClass.class, UnitTest.class.getField("SingleMemberShortField"),
++ SingleMemberShort.class);
++ checkEquals(SingleMemberIntClass.class, UnitTest.class.getField("SingleMemberIntField"),
++ SingleMemberInt.class);
++ checkEquals(SingleMemberLongClass.class, UnitTest.class.getField("SingleMemberLongField"),
++ SingleMemberLong.class);
++ checkEquals(SingleMemberCharClass.class, UnitTest.class.getField("SingleMemberCharField"),
++ SingleMemberChar.class);
++ checkEquals(SingleMemberFloatClass.class, UnitTest.class.getField("SingleMemberFloatField"),
++ SingleMemberFloat.class);
++ checkEquals(SingleMemberDoubleClass.class, UnitTest.class.getField("SingleMemberDoubleField"),
++ SingleMemberDouble.class);
++ checkEquals(SingleMemberBooleanClass.class, UnitTest.class.getField("SingleMemberBooleanField"),
++ SingleMemberBoolean.class);
++ checkEquals(SingleMemberStringClass.class, UnitTest.class.getField("SingleMemberStringField"),
++ SingleMemberString.class);
++ checkEquals(SingleMemberClassClass.class, UnitTest.class.getField("SingleMemberClassField"),
++ SingleMemberClass.class);
++ checkEquals(SingleMemberEnumClass.class, UnitTest.class.getField("SingleMemberEnumField"),
++ SingleMemberEnum.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE
++ checkEquals(SingleMemberByteOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteOvrdDefField"),
++ SingleMemberByteWithDef.class);
++ checkEquals(SingleMemberShortOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortOvrdDefField"),
++ SingleMemberShortWithDef.class);
++ checkEquals(SingleMemberIntOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntOvrdDefField"),
++ SingleMemberIntWithDef.class);
++ checkEquals(SingleMemberLongOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongOvrdDefField"),
++ SingleMemberLongWithDef.class);
++ checkEquals(SingleMemberCharOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharOvrdDefField"),
++ SingleMemberCharWithDef.class);
++ checkEquals(SingleMemberFloatOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatOvrdDefField"),
++ SingleMemberFloatWithDef.class);
++ checkEquals(SingleMemberDoubleOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleOvrdDefField"),
++ SingleMemberDoubleWithDef.class);
++ checkEquals(SingleMemberBooleanOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanOvrdDefField"),
++ SingleMemberBooleanWithDef.class);
++ checkEquals(SingleMemberStringOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringOvrdDefField"),
++ SingleMemberStringWithDef.class);
++ checkEquals(SingleMemberClassOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassOvrdDefField"),
++ SingleMemberClassWithDef.class);
++ checkEquals(SingleMemberEnumOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumOvrdDefField"),
++ SingleMemberEnumWithDef.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT
++ checkEquals(SingleMemberByteAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteAcceptDefField"),
++ SingleMemberByteWithDef.class);
++ checkEquals(SingleMemberShortAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortAcceptDefField"),
++ SingleMemberShortWithDef.class);
++ checkEquals(SingleMemberIntAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntAcceptDefField"),
++ SingleMemberIntWithDef.class);
++ checkEquals(SingleMemberLongAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongAcceptDefField"),
++ SingleMemberLongWithDef.class);
++ checkEquals(SingleMemberCharAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharAcceptDefField"),
++ SingleMemberCharWithDef.class);
++ checkEquals(SingleMemberFloatAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatAcceptDefField"),
++ SingleMemberFloatWithDef.class);
++ checkEquals(SingleMemberDoubleAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleAcceptDefField"),
++ SingleMemberDoubleWithDef.class);
++ checkEquals(SingleMemberBooleanAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanAcceptDefField"),
++ SingleMemberBooleanWithDef.class);
++ checkEquals(SingleMemberStringAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringAcceptDefField"),
++ SingleMemberStringWithDef.class);
++ checkEquals(SingleMemberClassAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassAcceptDefField"),
++ SingleMemberClassWithDef.class);
++ checkEquals(SingleMemberEnumAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumAcceptDefField"),
++ SingleMemberEnumWithDef.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY)
++ checkEquals(SingleMemberByteArrEmptyClass.class, UnitTest.class.getField("SingleMemberByteArrEmptyField"),
++ SingleMemberByteArray.class);
++ checkEquals(SingleMemberShortArrEmptyClass.class, UnitTest.class.getField("SingleMemberShortArrEmptyField"),
++ SingleMemberShortArray.class);
++ checkEquals(SingleMemberIntArrEmptyClass.class, UnitTest.class.getField("SingleMemberIntArrEmptyField"),
++ SingleMemberIntArray.class);
++ checkEquals(SingleMemberLongArrEmptyClass.class, UnitTest.class.getField("SingleMemberLongArrEmptyField"),
++ SingleMemberLongArray.class);
++ checkEquals(SingleMemberCharArrEmptyClass.class, UnitTest.class.getField("SingleMemberCharArrEmptyField"),
++ SingleMemberCharArray.class);
++ checkEquals(SingleMemberFloatArrEmptyClass.class, UnitTest.class.getField("SingleMemberFloatArrEmptyField"),
++ SingleMemberFloatArray.class);
++ checkEquals(SingleMemberDoubleArrEmptyClass.class, UnitTest.class.getField("SingleMemberDoubleArrEmptyField"),
++ SingleMemberDoubleArray.class);
++ checkEquals(SingleMemberBooleanArrEmptyClass.class, UnitTest.class.getField("SingleMemberBooleanArrEmptyField"),
++ SingleMemberBooleanArray.class);
++ checkEquals(SingleMemberStringArrEmptyClass.class, UnitTest.class.getField("SingleMemberStringArrEmptyField"),
++ SingleMemberStringArray.class);
++ checkEquals(SingleMemberClassArrEmptyClass.class, UnitTest.class.getField("SingleMemberClassArrEmptyField"),
++ SingleMemberClassArray.class);
++ checkEquals(SingleMemberEnumArrEmptyClass.class, UnitTest.class.getField("SingleMemberEnumArrEmptyField"),
++ SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY)
++ checkEquals(SingleMemberByteArrOneClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"),
++ SingleMemberByteArray.class);
++ checkEquals(SingleMemberShortArrOneClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"),
++ SingleMemberShortArray.class);
++ checkEquals(SingleMemberIntArrOneClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"),
++ SingleMemberIntArray.class);
++ checkEquals(SingleMemberLongArrOneClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"),
++ SingleMemberLongArray.class);
++ checkEquals(SingleMemberCharArrOneClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"),
++ SingleMemberCharArray.class);
++ checkEquals(SingleMemberFloatArrOneClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"),
++ SingleMemberFloatArray.class);
++ checkEquals(SingleMemberDoubleArrOneClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"),
++ SingleMemberDoubleArray.class);
++ checkEquals(SingleMemberBooleanArrOneClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"),
++ SingleMemberBooleanArray.class);
++ checkEquals(SingleMemberStringArrOneClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"),
++ SingleMemberStringArray.class);
++ checkEquals(SingleMemberClassArrOneClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"),
++ SingleMemberClassArray.class);
++ checkEquals(SingleMemberEnumArrOneClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"),
++ SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY)
++ checkEquals(SingleMemberByteArrTwoClass.class, UnitTest.class.getField("SingleMemberByteArrTwoField"),
++ SingleMemberByteArray.class);
++ checkEquals(SingleMemberShortArrTwoClass.class, UnitTest.class.getField("SingleMemberShortArrTwoField"),
++ SingleMemberShortArray.class);
++ checkEquals(SingleMemberIntArrTwoClass.class, UnitTest.class.getField("SingleMemberIntArrTwoField"),
++ SingleMemberIntArray.class);
++ checkEquals(SingleMemberLongArrTwoClass.class, UnitTest.class.getField("SingleMemberLongArrTwoField"),
++ SingleMemberLongArray.class);
++ checkEquals(SingleMemberCharArrTwoClass.class, UnitTest.class.getField("SingleMemberCharArrTwoField"),
++ SingleMemberCharArray.class);
++ checkEquals(SingleMemberFloatArrTwoClass.class, UnitTest.class.getField("SingleMemberFloatArrTwoField"),
++ SingleMemberFloatArray.class);
++ checkEquals(SingleMemberDoubleArrTwoClass.class, UnitTest.class.getField("SingleMemberDoubleArrTwoField"),
++ SingleMemberDoubleArray.class);
++ checkEquals(SingleMemberBooleanArrTwoClass.class, UnitTest.class.getField("SingleMemberBooleanArrTwoField"),
++ SingleMemberBooleanArray.class);
++ checkEquals(SingleMemberStringArrTwoClass.class, UnitTest.class.getField("SingleMemberStringArrTwoField"),
++ SingleMemberStringArray.class);
++ checkEquals(SingleMemberClassArrTwoClass.class, UnitTest.class.getField("SingleMemberClassArrTwoField"),
++ SingleMemberClassArray.class);
++ checkEquals(SingleMemberEnumArrTwoClass.class, UnitTest.class.getField("SingleMemberEnumArrTwoField"),
++ SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)
++ checkEquals(SingleMemberByteArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteArrOvrdDefField"),
++ SingleMemberByteArrayDef.class);
++ checkEquals(SingleMemberShortArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortArrOvrdDefField"),
++ SingleMemberShortArrayDef.class);
++ checkEquals(SingleMemberIntArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntArrOvrdDefField"),
++ SingleMemberIntArrayDef.class);
++ checkEquals(SingleMemberLongArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongArrOvrdDefField"),
++ SingleMemberLongArrayDef.class);
++ checkEquals(SingleMemberCharArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharArrOvrdDefField"),
++ SingleMemberCharArrayDef.class);
++ checkEquals(SingleMemberFloatArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"),
++ SingleMemberFloatArrayDef.class);
++ checkEquals(SingleMemberDoubleArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"),
++ SingleMemberDoubleArrayDef.class);
++ checkEquals(SingleMemberBooleanArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"),
++ SingleMemberBooleanArrayDef.class);
++ checkEquals(SingleMemberStringArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringArrOvrdDefField"),
++ SingleMemberStringArrayDef.class);
++ checkEquals(SingleMemberClassArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassArrOvrdDefField"),
++ SingleMemberClassArrayDef.class);
++ checkEquals(SingleMemberEnumArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"),
++ SingleMemberEnumArrayDef.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)
++ checkEquals(SingleMemberByteArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteArrAcceptDefField"),
++ SingleMemberByteArrayDef.class);
++ checkEquals(SingleMemberShortArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortArrAcceptDefField"),
++ SingleMemberShortArrayDef.class);
++ checkEquals(SingleMemberIntArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntArrAcceptDefField"),
++ SingleMemberIntArrayDef.class);
++ checkEquals(SingleMemberLongArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongArrAcceptDefField"),
++ SingleMemberLongArrayDef.class);
++ checkEquals(SingleMemberCharArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharArrAcceptDefField"),
++ SingleMemberCharArrayDef.class);
++ checkEquals(SingleMemberFloatArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"),
++ SingleMemberFloatArrayDef.class);
++ checkEquals(SingleMemberDoubleArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"),
++ SingleMemberDoubleArrayDef.class);
++ checkEquals(SingleMemberBooleanArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"),
++ SingleMemberBooleanArrayDef.class);
++ checkEquals(SingleMemberStringArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringArrAcceptDefField"),
++ SingleMemberStringArrayDef.class);
++ checkEquals(SingleMemberClassArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassArrAcceptDefField"),
++ SingleMemberClassArrayDef.class);
++ checkEquals(SingleMemberEnumArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"),
++ SingleMemberEnumArrayDef.class);
++
++ // *** TESTS FOR EQUALS AND HASHCODE - NEGATIVE
++
++ // MULTIMEMBER SCALAR TYPES
++ checkUnequals(scalarTypesOverrideDefaultClass.class, UnitTest.class.getField("scalarTypesAcceptDefaultField"),
++ ScalarTypesWithDefault.class);
++ checkUnequals(scalarTypesAcceptDefaultClass.class, UnitTest.class.getField("scalarTypesOverrideDefaultField"),
++ ScalarTypesWithDefault.class);
++
++ // MULTIMEMBER ARRAY TYPES
++ checkUnequals(emptyArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"),
++ ArrayTypes.class);
++ checkUnequals(singleElementArrayTypesClass.class, UnitTest.class.getField("twoElementArrayTypesField"),
++ ArrayTypes.class);
++ checkUnequals(twoElementArrayTypesClass.class, UnitTest.class.getField("singleElementArrayTypesField"),
++ ArrayTypes.class);
++ checkUnequals(arrayTypesOverrideDefaultClass.class, UnitTest.class.getField("arrayTypesAcceptDefaultField"),
++ ArrayTypesWithDefault.class);
++ checkUnequals(arrayTypesAcceptDefaultClass.class, UnitTest.class.getField("arrayTypesOverrideDefaultField"),
++ ArrayTypesWithDefault.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE
++ checkUnequals(SingleMemberByteOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteAcceptDefField"),
++ SingleMemberByteWithDef.class);
++ checkUnequals(SingleMemberShortOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortAcceptDefField"),
++ SingleMemberShortWithDef.class);
++ checkUnequals(SingleMemberIntOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntAcceptDefField"),
++ SingleMemberIntWithDef.class);
++ checkUnequals(SingleMemberLongOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongAcceptDefField"),
++ SingleMemberLongWithDef.class);
++ checkUnequals(SingleMemberCharOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharAcceptDefField"),
++ SingleMemberCharWithDef.class);
++ checkUnequals(SingleMemberFloatOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatAcceptDefField"),
++ SingleMemberFloatWithDef.class);
++ checkUnequals(SingleMemberDoubleOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleAcceptDefField"),
++ SingleMemberDoubleWithDef.class);
++ checkUnequals(SingleMemberBooleanOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanAcceptDefField"),
++ SingleMemberBooleanWithDef.class);
++ checkUnequals(SingleMemberStringOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringAcceptDefField"),
++ SingleMemberStringWithDef.class);
++ checkUnequals(SingleMemberClassOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassAcceptDefField"),
++ SingleMemberClassWithDef.class);
++ checkUnequals(SingleMemberEnumOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumAcceptDefField"),
++ SingleMemberEnumWithDef.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT
++ checkUnequals(SingleMemberByteAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteOvrdDefField"),
++ SingleMemberByteWithDef.class);
++ checkUnequals(SingleMemberShortAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortOvrdDefField"),
++ SingleMemberShortWithDef.class);
++ checkUnequals(SingleMemberIntAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntOvrdDefField"),
++ SingleMemberIntWithDef.class);
++ checkUnequals(SingleMemberLongAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongOvrdDefField"),
++ SingleMemberLongWithDef.class);
++ checkUnequals(SingleMemberCharAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharOvrdDefField"),
++ SingleMemberCharWithDef.class);
++ checkUnequals(SingleMemberFloatAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatOvrdDefField"),
++ SingleMemberFloatWithDef.class);
++ checkUnequals(SingleMemberDoubleAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleOvrdDefField"),
++ SingleMemberDoubleWithDef.class);
++ checkUnequals(SingleMemberBooleanAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanOvrdDefField"),
++ SingleMemberBooleanWithDef.class);
++ checkUnequals(SingleMemberStringAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringOvrdDefField"),
++ SingleMemberStringWithDef.class);
++ checkUnequals(SingleMemberClassAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassOvrdDefField"),
++ SingleMemberClassWithDef.class);
++ checkUnequals(SingleMemberEnumAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumOvrdDefField"),
++ SingleMemberEnumWithDef.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY)
++ checkUnequals(SingleMemberByteArrEmptyClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"),
++ SingleMemberByteArray.class);
++ checkUnequals(SingleMemberShortArrEmptyClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"),
++ SingleMemberShortArray.class);
++ checkUnequals(SingleMemberIntArrEmptyClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"),
++ SingleMemberIntArray.class);
++ checkUnequals(SingleMemberLongArrEmptyClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"),
++ SingleMemberLongArray.class);
++ checkUnequals(SingleMemberCharArrEmptyClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"),
++ SingleMemberCharArray.class);
++ checkUnequals(SingleMemberFloatArrEmptyClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"),
++ SingleMemberFloatArray.class);
++ checkUnequals(SingleMemberDoubleArrEmptyClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"),
++ SingleMemberDoubleArray.class);
++ checkUnequals(SingleMemberBooleanArrEmptyClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"),
++ SingleMemberBooleanArray.class);
++ checkUnequals(SingleMemberStringArrEmptyClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"),
++ SingleMemberStringArray.class);
++ checkUnequals(SingleMemberClassArrEmptyClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"),
++ SingleMemberClassArray.class);
++ checkUnequals(SingleMemberEnumArrEmptyClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"),
++ SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY)
++ checkUnequals(SingleMemberByteArrOneClass.class, UnitTest.class.getField("SingleMemberByteArrTwoField"),
++ SingleMemberByteArray.class);
++ checkUnequals(SingleMemberShortArrOneClass.class, UnitTest.class.getField("SingleMemberShortArrTwoField"),
++ SingleMemberShortArray.class);
++ checkUnequals(SingleMemberIntArrOneClass.class, UnitTest.class.getField("SingleMemberIntArrTwoField"),
++ SingleMemberIntArray.class);
++ checkUnequals(SingleMemberLongArrOneClass.class, UnitTest.class.getField("SingleMemberLongArrTwoField"),
++ SingleMemberLongArray.class);
++ checkUnequals(SingleMemberCharArrOneClass.class, UnitTest.class.getField("SingleMemberCharArrTwoField"),
++ SingleMemberCharArray.class);
++ checkUnequals(SingleMemberFloatArrOneClass.class, UnitTest.class.getField("SingleMemberFloatArrTwoField"),
++ SingleMemberFloatArray.class);
++ checkUnequals(SingleMemberDoubleArrOneClass.class, UnitTest.class.getField("SingleMemberDoubleArrTwoField"),
++ SingleMemberDoubleArray.class);
++ checkUnequals(SingleMemberBooleanArrOneClass.class, UnitTest.class.getField("SingleMemberBooleanArrTwoField"),
++ SingleMemberBooleanArray.class);
++ checkUnequals(SingleMemberStringArrOneClass.class, UnitTest.class.getField("SingleMemberStringArrTwoField"),
++ SingleMemberStringArray.class);
++ checkUnequals(SingleMemberClassArrOneClass.class, UnitTest.class.getField("SingleMemberClassArrTwoField"),
++ SingleMemberClassArray.class);
++ checkUnequals(SingleMemberEnumArrOneClass.class, UnitTest.class.getField("SingleMemberEnumArrTwoField"),
++ SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY)
++ checkUnequals(SingleMemberByteArrTwoClass.class, UnitTest.class.getField("SingleMemberByteArrOneField"),
++ SingleMemberByteArray.class);
++ checkUnequals(SingleMemberShortArrTwoClass.class, UnitTest.class.getField("SingleMemberShortArrOneField"),
++ SingleMemberShortArray.class);
++ checkUnequals(SingleMemberIntArrTwoClass.class, UnitTest.class.getField("SingleMemberIntArrOneField"),
++ SingleMemberIntArray.class);
++ checkUnequals(SingleMemberLongArrTwoClass.class, UnitTest.class.getField("SingleMemberLongArrOneField"),
++ SingleMemberLongArray.class);
++ checkUnequals(SingleMemberCharArrTwoClass.class, UnitTest.class.getField("SingleMemberCharArrOneField"),
++ SingleMemberCharArray.class);
++ checkUnequals(SingleMemberFloatArrTwoClass.class, UnitTest.class.getField("SingleMemberFloatArrOneField"),
++ SingleMemberFloatArray.class);
++ checkUnequals(SingleMemberDoubleArrTwoClass.class, UnitTest.class.getField("SingleMemberDoubleArrOneField"),
++ SingleMemberDoubleArray.class);
++ checkUnequals(SingleMemberBooleanArrTwoClass.class, UnitTest.class.getField("SingleMemberBooleanArrOneField"),
++ SingleMemberBooleanArray.class);
++ checkUnequals(SingleMemberStringArrTwoClass.class, UnitTest.class.getField("SingleMemberStringArrOneField"),
++ SingleMemberStringArray.class);
++ checkUnequals(SingleMemberClassArrTwoClass.class, UnitTest.class.getField("SingleMemberClassArrOneField"),
++ SingleMemberClassArray.class);
++ checkUnequals(SingleMemberEnumArrTwoClass.class, UnitTest.class.getField("SingleMemberEnumArrOneField"),
++ SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)
++ checkUnequals(SingleMemberByteArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberByteArrAcceptDefField"),
++ SingleMemberByteArrayDef.class);
++ checkUnequals(SingleMemberShortArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberShortArrAcceptDefField"),
++ SingleMemberShortArrayDef.class);
++ checkUnequals(SingleMemberIntArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberIntArrAcceptDefField"),
++ SingleMemberIntArrayDef.class);
++ checkUnequals(SingleMemberLongArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberLongArrAcceptDefField"),
++ SingleMemberLongArrayDef.class);
++ checkUnequals(SingleMemberCharArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberCharArrAcceptDefField"),
++ SingleMemberCharArrayDef.class);
++ checkUnequals(SingleMemberFloatArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberFloatArrAcceptDefField"),
++ SingleMemberFloatArrayDef.class);
++ checkUnequals(SingleMemberDoubleArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrAcceptDefField"),
++ SingleMemberDoubleArrayDef.class);
++ checkUnequals(SingleMemberBooleanArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrAcceptDefField"),
++ SingleMemberBooleanArrayDef.class);
++ checkUnequals(SingleMemberStringArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberStringArrAcceptDefField"),
++ SingleMemberStringArrayDef.class);
++ checkUnequals(SingleMemberClassArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberClassArrAcceptDefField"),
++ SingleMemberClassArrayDef.class);
++ checkUnequals(SingleMemberEnumArrOvrdDefClass.class, UnitTest.class.getField("SingleMemberEnumArrAcceptDefField"),
++ SingleMemberEnumArrayDef.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)
++ checkUnequals(SingleMemberByteArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberByteArrOvrdDefField"),
++ SingleMemberByteArrayDef.class);
++ checkUnequals(SingleMemberShortArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberShortArrOvrdDefField"),
++ SingleMemberShortArrayDef.class);
++ checkUnequals(SingleMemberIntArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberIntArrOvrdDefField"),
++ SingleMemberIntArrayDef.class);
++ checkUnequals(SingleMemberLongArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberLongArrOvrdDefField"),
++ SingleMemberLongArrayDef.class);
++ checkUnequals(SingleMemberCharArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberCharArrOvrdDefField"),
++ SingleMemberCharArrayDef.class);
++ checkUnequals(SingleMemberFloatArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberFloatArrOvrdDefField"),
++ SingleMemberFloatArrayDef.class);
++ checkUnequals(SingleMemberDoubleArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberDoubleArrOvrdDefField"),
++ SingleMemberDoubleArrayDef.class);
++ checkUnequals(SingleMemberBooleanArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberBooleanArrOvrdDefField"),
++ SingleMemberBooleanArrayDef.class);
++ checkUnequals(SingleMemberStringArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberStringArrOvrdDefField"),
++ SingleMemberStringArrayDef.class);
++ checkUnequals(SingleMemberClassArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberClassArrOvrdDefField"),
++ SingleMemberClassArrayDef.class);
++ checkUnequals(SingleMemberEnumArrAcceptDefClass.class, UnitTest.class.getField("SingleMemberEnumArrOvrdDefField"),
++ SingleMemberEnumArrayDef.class);
++
++ // *** TESTS FOR SERIALIZATION AND DESERIALIZATION
++
++ // MULTIMEMBER SCALAR TYPES
++ checkSerialization(scalarTypesClass.class, ScalarTypes.class);
++ checkSerialization(scalarTypesOverrideDefaultClass.class, ScalarTypesWithDefault.class);
++ checkSerialization(scalarTypesAcceptDefaultClass.class, ScalarTypesWithDefault.class);
++
++ // MULTIMEMBER ARRAY TYPES
++ checkSerialization(emptyArrayTypesClass.class, ArrayTypes.class);
++ checkSerialization(singleElementArrayTypesClass.class, ArrayTypes.class);
++ checkSerialization(twoElementArrayTypesClass.class, ArrayTypes.class);
++ checkSerialization(arrayTypesOverrideDefaultClass.class, ArrayTypesWithDefault.class);
++ checkSerialization(arrayTypesAcceptDefaultClass.class, ArrayTypesWithDefault.class);
++
++ // MARKER TYPE
++ checkSerialization(markerClass.class, Marker.class);
++
++ // SINGLE-MEMBER SCALAR TYPES
++ checkSerialization(SingleMemberByteClass.class, SingleMemberByte.class);
++ checkSerialization(SingleMemberShortClass.class, SingleMemberShort.class);
++ checkSerialization(SingleMemberIntClass.class, SingleMemberInt.class);
++ checkSerialization(SingleMemberLongClass.class, SingleMemberLong.class);
++ checkSerialization(SingleMemberCharClass.class, SingleMemberChar.class);
++ checkSerialization(SingleMemberFloatClass.class, SingleMemberFloat.class);
++ checkSerialization(SingleMemberDoubleClass.class, SingleMemberDouble.class);
++ checkSerialization(SingleMemberBooleanClass.class, SingleMemberBoolean.class);
++ checkSerialization(SingleMemberStringClass.class, SingleMemberString.class);
++ checkSerialization(SingleMemberClassClass.class, SingleMemberClass.class);
++ checkSerialization(SingleMemberEnumClass.class, SingleMemberEnum.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-OVERRIDE
++ checkSerialization(SingleMemberByteOvrdDefClass.class, SingleMemberByteWithDef.class);
++ checkSerialization(SingleMemberShortOvrdDefClass.class, SingleMemberShortWithDef.class);
++ checkSerialization(SingleMemberIntOvrdDefClass.class, SingleMemberIntWithDef.class);
++ checkSerialization(SingleMemberLongOvrdDefClass.class, SingleMemberLongWithDef.class);
++ checkSerialization(SingleMemberCharOvrdDefClass.class, SingleMemberCharWithDef.class);
++ checkSerialization(SingleMemberFloatOvrdDefClass.class, SingleMemberFloatWithDef.class);
++ checkSerialization(SingleMemberDoubleOvrdDefClass.class, SingleMemberDoubleWithDef.class);
++ checkSerialization(SingleMemberBooleanOvrdDefClass.class, SingleMemberBooleanWithDef.class);
++ checkSerialization(SingleMemberStringOvrdDefClass.class, SingleMemberStringWithDef.class);
++ checkSerialization(SingleMemberClassOvrdDefClass.class, SingleMemberClassWithDef.class);
++ checkSerialization(SingleMemberEnumOvrdDefClass.class, SingleMemberEnumWithDef.class);
++
++ // SINGLE-MEMBER SCALAR TYPES WITH DEFAULT-ACCEPT
++ checkSerialization(SingleMemberByteAcceptDefClass.class, SingleMemberByteWithDef.class);
++ checkSerialization(SingleMemberShortAcceptDefClass.class, SingleMemberShortWithDef.class);
++ checkSerialization(SingleMemberIntAcceptDefClass.class, SingleMemberIntWithDef.class);
++ checkSerialization(SingleMemberLongAcceptDefClass.class, SingleMemberLongWithDef.class);
++ checkSerialization(SingleMemberCharAcceptDefClass.class, SingleMemberCharWithDef.class);
++ checkSerialization(SingleMemberFloatAcceptDefClass.class, SingleMemberFloatWithDef.class);
++ checkSerialization(SingleMemberDoubleAcceptDefClass.class, SingleMemberDoubleWithDef.class);
++ checkSerialization(SingleMemberBooleanAcceptDefClass.class, SingleMemberBooleanWithDef.class);
++ checkSerialization(SingleMemberStringAcceptDefClass.class, SingleMemberStringWithDef.class);
++ checkSerialization(SingleMemberClassAcceptDefClass.class, SingleMemberClassWithDef.class);
++ checkSerialization(SingleMemberEnumAcceptDefClass.class, SingleMemberEnumWithDef.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (EMPTY ARRAY)
++ checkSerialization(SingleMemberByteArrEmptyClass.class, SingleMemberByteArray.class);
++ checkSerialization(SingleMemberShortArrEmptyClass.class, SingleMemberShortArray.class);
++ checkSerialization(SingleMemberIntArrEmptyClass.class, SingleMemberIntArray.class);
++ checkSerialization(SingleMemberLongArrEmptyClass.class, SingleMemberLongArray.class);
++ checkSerialization(SingleMemberCharArrEmptyClass.class, SingleMemberCharArray.class);
++ checkSerialization(SingleMemberFloatArrEmptyClass.class, SingleMemberFloatArray.class);
++ checkSerialization(SingleMemberDoubleArrEmptyClass.class, SingleMemberDoubleArray.class);
++ checkSerialization(SingleMemberBooleanArrEmptyClass.class, SingleMemberBooleanArray.class);
++ checkSerialization(SingleMemberStringArrEmptyClass.class, SingleMemberStringArray.class);
++ checkSerialization(SingleMemberClassArrEmptyClass.class, SingleMemberClassArray.class);
++ checkSerialization(SingleMemberEnumArrEmptyClass.class, SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (ONE-ELEMENT ARRAY)
++ checkSerialization(SingleMemberByteArrOneClass.class, SingleMemberByteArray.class);
++ checkSerialization(SingleMemberShortArrOneClass.class, SingleMemberShortArray.class);
++ checkSerialization(SingleMemberIntArrOneClass.class, SingleMemberIntArray.class);
++ checkSerialization(SingleMemberLongArrOneClass.class, SingleMemberLongArray.class);
++ checkSerialization(SingleMemberCharArrOneClass.class, SingleMemberCharArray.class);
++ checkSerialization(SingleMemberFloatArrOneClass.class, SingleMemberFloatArray.class);
++ checkSerialization(SingleMemberDoubleArrOneClass.class, SingleMemberDoubleArray.class);
++ checkSerialization(SingleMemberBooleanArrOneClass.class, SingleMemberBooleanArray.class);
++ checkSerialization(SingleMemberStringArrOneClass.class, SingleMemberStringArray.class);
++ checkSerialization(SingleMemberClassArrOneClass.class, SingleMemberClassArray.class);
++ checkSerialization(SingleMemberEnumArrOneClass.class, SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES (TWO-ELEMENT ARRAY)
++ checkSerialization(SingleMemberByteArrTwoClass.class, SingleMemberByteArray.class);
++ checkSerialization(SingleMemberShortArrTwoClass.class, SingleMemberShortArray.class);
++ checkSerialization(SingleMemberIntArrTwoClass.class, SingleMemberIntArray.class);
++ checkSerialization(SingleMemberLongArrTwoClass.class, SingleMemberLongArray.class);
++ checkSerialization(SingleMemberCharArrTwoClass.class, SingleMemberCharArray.class);
++ checkSerialization(SingleMemberFloatArrTwoClass.class, SingleMemberFloatArray.class);
++ checkSerialization(SingleMemberDoubleArrTwoClass.class, SingleMemberDoubleArray.class);
++ checkSerialization(SingleMemberBooleanArrTwoClass.class, SingleMemberBooleanArray.class);
++ checkSerialization(SingleMemberStringArrTwoClass.class, SingleMemberStringArray.class);
++ checkSerialization(SingleMemberClassArrTwoClass.class, SingleMemberClassArray.class);
++ checkSerialization(SingleMemberEnumArrTwoClass.class, SingleMemberEnumArray.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (OVERRIDE)
++ checkSerialization(SingleMemberByteArrOvrdDefClass.class, SingleMemberByteArrayDef.class);
++ checkSerialization(SingleMemberShortArrOvrdDefClass.class, SingleMemberShortArrayDef.class);
++ checkSerialization(SingleMemberIntArrOvrdDefClass.class, SingleMemberIntArrayDef.class);
++ checkSerialization(SingleMemberLongArrOvrdDefClass.class, SingleMemberLongArrayDef.class);
++ checkSerialization(SingleMemberCharArrOvrdDefClass.class, SingleMemberCharArrayDef.class);
++ checkSerialization(SingleMemberFloatArrOvrdDefClass.class, SingleMemberFloatArrayDef.class);
++ checkSerialization(SingleMemberDoubleArrOvrdDefClass.class, SingleMemberDoubleArrayDef.class);
++ checkSerialization(SingleMemberBooleanArrOvrdDefClass.class, SingleMemberBooleanArrayDef.class);
++ checkSerialization(SingleMemberStringArrOvrdDefClass.class, SingleMemberStringArrayDef.class);
++ checkSerialization(SingleMemberClassArrOvrdDefClass.class, SingleMemberClassArrayDef.class);
++ checkSerialization(SingleMemberEnumArrOvrdDefClass.class, SingleMemberEnumArrayDef.class);
++
++ // SINGLE-MEMBER ARRAY TYPES WITH DEFAULT (ACCEPT)
++ checkSerialization(SingleMemberByteArrAcceptDefClass.class, SingleMemberByteArrayDef.class);
++ checkSerialization(SingleMemberShortArrAcceptDefClass.class, SingleMemberShortArrayDef.class);
++ checkSerialization(SingleMemberIntArrAcceptDefClass.class, SingleMemberIntArrayDef.class);
++ checkSerialization(SingleMemberLongArrAcceptDefClass.class, SingleMemberLongArrayDef.class);
++ checkSerialization(SingleMemberCharArrAcceptDefClass.class, SingleMemberCharArrayDef.class);
++ checkSerialization(SingleMemberFloatArrAcceptDefClass.class, SingleMemberFloatArrayDef.class);
++ checkSerialization(SingleMemberDoubleArrAcceptDefClass.class, SingleMemberDoubleArrayDef.class);
++ checkSerialization(SingleMemberBooleanArrAcceptDefClass.class, SingleMemberBooleanArrayDef.class);
++ checkSerialization(SingleMemberStringArrAcceptDefClass.class, SingleMemberStringArrayDef.class);
++ checkSerialization(SingleMemberClassArrAcceptDefClass.class, SingleMemberClassArrayDef.class);
++ checkSerialization(SingleMemberEnumArrAcceptDefClass.class, SingleMemberEnumArrayDef.class);
++
++ // *** TESTS FOR ANNOTATION INHERITANCE AND ENUMERATING DECLARED ANNOTATIONS
++
++ // Inheritance tests
++ checkInheritence(Grandpa.class, true, true);
++ checkInheritence(Dad.class, true, false);
++ checkInheritence(Son.class, true, true);
++
++ // Declared annotations tests
++ checkDeclaredAnnotations(Grandpa.class, true, true);
++ checkDeclaredAnnotations(Dad.class, false, false);
++ checkDeclaredAnnotations(Son.class, false, true);
++
++ // Generate summary
++ System.out.println("\n" + numTests + " tests completed");
++ if (failCount != 0)
++ throw new Exception("Failure count: " + failCount);
++ else
++ System.out.println("Success.");
++ }
++
++ static int failCount = 0;
++
++ private static void fail(String test) {
++ System.out.println("Failure: " + test);
++ failCount++;
++ }
++
++ // ANNOTATION-VERIFICATION METHODS
++
++ // Scalar multi-member
++
++ static void checkScalarTypes(AnnotatedElement e) {
++ try {
++ checkScalarTypes(e.getAnnotation(ScalarTypes.class), e);
++ } catch(Throwable t) {
++ fail("ScalarTypes " + e + ": " + t);
++ t.printStackTrace();
++ }
++ }
++
++ static void checkScalarTypes(ScalarTypes st, AnnotatedElement e) throws Exception {
++ numTests++;
++ if (!(st.b() == 1 &&
++ st.s() == 2 &&
++ st.i() == 3 &&
++ st.l() == 4L &&
++ st.c() == '5' &&
++ st.f() == 6.0f &&
++ st.d() == 7.0 &&
++ st.bool() == true &&
++ st.str().equals("custom") &&
++ st.cls() == Map.class &&
++ st.e() == Stooge.MOE &&
++ st.a().x() == 1 && st.a().y() == 2))
++ fail("ScalarTypes" + e);
++ }
++
++ static void checkScalarTypesOverrideDefault(AnnotatedElement e) {
++ try {
++ checkScalarTypesOverrideDefault(e.getAnnotation(ScalarTypesWithDefault.class), e);
++ } catch(Throwable t) {
++ fail("ScalarTypesOverrideDefaults" + e + ": " + t);
++ }
++ }
++
++ static void checkScalarTypesOverrideDefault(ScalarTypesWithDefault st, AnnotatedElement e) {
++ numTests++;
++ if (!(st.b() == 1 &&
++ st.s() == 2 &&
++ st.i() == 3 &&
++ st.l() == 4L &&
++ st.c() == '5' &&
++ st.f() == 6.0f &&
++ st.d() == 7.0 &&
++ st.bool() == true &&
++ st.str().equals("custom") &&
++ st.cls() == Map.class &&
++ st.e() == Stooge.MOE))
++ fail("ScalarTypesOverrideDefaults" + e);
++ }
++
++ static void checkScalarTypesAcceptDefault(AnnotatedElement e) {
++ try {
++ checkScalarTypesAcceptDefault(e.getAnnotation(ScalarTypesWithDefault.class), e);
++ } catch(Throwable t) {
++ fail("ScalarTypesAcceptDefaults" + e + ": " + t);
++ }
++ }
++
++ static void checkScalarTypesAcceptDefault(ScalarTypesWithDefault st, AnnotatedElement e) {
++ numTests++;
++ if (!(st.b() == 11 &&
++ st.s() == 12 &&
++ st.i() == 13 &&
++ st.l() == 14L &&
++ st.c() == 'V' &&
++ st.f() == 16.0f &&
++ st.d() == 17.0 &&
++ st.bool() == false &&
++ st.str().equals("default") &&
++ st.cls() == Class.class &&
++ st.e() == Stooge.LARRY &&
++ st.a().x() == 11 && st.a().y() == 12))
++ fail("ScalarTypesAcceptDefaults" + e);
++ }
++
++ // Array multi-member
++
++ static void checkArrayTypes0(AnnotatedElement e) {
++ try {
++ checkArrayTypes0(e.getAnnotation(ArrayTypes.class), e);
++ } catch(Throwable t) {
++ fail("ArrayTypes(Empty)" + e + ": " + t);
++ }
++ }
++
++ static void checkArrayTypes0(ArrayTypes at, AnnotatedElement e) {
++ numTests++;
++ if (!(at.b().length == 0 &&
++ at.s().length == 0 &&
++ at.i().length == 0 &&
++ at.l().length == 0 &&
++ at.c().length == 0 &&
++ at.f().length == 0 &&
++ at.d().length == 0 &&
++ at.bool().length == 0 &&
++ at.str().length == 0 &&
++ at.cls().length == 0 &&
++ at.e().length == 0 &&
++ at.a().length == 0)) {
++ fail("ArrayTypes(Empty)" + e);
++ }
++ }
++
++ static void checkArrayTypes1(AnnotatedElement e) {
++ try {
++ checkArrayTypes1(e.getAnnotation(ArrayTypes.class), e);
++ } catch(Throwable t) {
++ fail("ArrayTypes(One element)" + e + ": " + t);
++ }
++ }
++
++ static void checkArrayTypes1(ArrayTypes at, AnnotatedElement e) {
++ numTests++;
++ if (!(at.b()[0] == 1 &&
++ at.s()[0] == 2 &&
++ at.i()[0] == 3 &&
++ at.l()[0] == 4L &&
++ at.c()[0] == '5' &&
++ at.f()[0] == 6.0f &&
++ at.d()[0] == 7.0 &&
++ at.bool()[0] == true &&
++ at.str()[0].equals("custom") &&
++ at.cls()[0] == Map.class &&
++ at.e()[0] == Stooge.MOE &&
++ at.a()[0].x() == 1 && at.a()[0].y() == 2 &&
++
++ at.b().length==1 && at.s().length==1 && at.i().length==1 &&
++ at.l().length==1 && at.c().length==1 && at.d().length==1 &&
++ at.bool().length==1 && at.str().length==1 &&
++ at.cls().length==1 && at.cls().length==1 && at.a().length==1))
++ fail("ArrayTypes(One element)" + e);
++ }
++
++ static void checkArrayTypes2(AnnotatedElement e) {
++ try {
++ checkArrayTypes2(e.getAnnotation(ArrayTypes.class), e);
++ } catch(Throwable t) {
++ fail("ArrayTypes(Two element)" + e + ": " + t);
++ }
++ }
++
++ static void checkArrayTypes2(ArrayTypes at, AnnotatedElement e) {
++ numTests++;
++ if (!(at.b()[0] == 1 && at.b()[1] == 2 &&
++ at.s()[0] == 2 && at.s()[1] == 3 &&
++ at.i()[0] == 3 && at.i()[1] == 4 &&
++ at.l()[0] == 4L && at.l()[1] == 5L &&
++ at.c()[0] == '5' && at.c()[1] == '6' &&
++ at.f()[0] == 6.0f && at.f()[1] == 7.0f &&
++ at.d()[0] == 7.0 && at.d()[1] == 8.0 &&
++ at.bool()[0] == true && at.bool()[1] == false &&
++ at.str()[0].equals("custom") && at.str()[1].equals("paint") &&
++ at.cls()[0] == Map.class && at.cls()[1] == Set.class &&
++ at.e()[0] == Stooge.MOE && at.e()[1] == Stooge.CURLY &&
++ at.a()[0].x() == 1 && at.a()[0].y() == 2 && at.a()[1].x() == 3 && at.a()[1].y() == 4 &&
++
++ at.b().length==2 && at.s().length==2 && at.i().length==2 &&
++ at.l().length==2 && at.c().length==2 && at.d().length==2 &&
++ at.bool().length==2 && at.str().length==2 &&
++ at.cls().length==2 && at.cls().length==2 && at.a().length==2))
++ fail("ArrayTypes(Two element)" + e);
++ }
++
++ static void checkArrayTypesOverrideDefault(AnnotatedElement e) {
++ try {
++ checkArrayTypesOverrideDefault(e.getAnnotation(ArrayTypesWithDefault.class), e);
++ } catch(Throwable t) {
++ fail("ArrayTypesOverrideDefault" + e + ": " + t);
++ }
++ }
++
++ static void checkArrayTypesOverrideDefault(ArrayTypesWithDefault at, AnnotatedElement e) {
++ numTests++;
++ if (!(at.b()[0] == 1 &&
++ at.s()[0] == 2 &&
++ at.i()[0] == 3 &&
++ at.l()[0] == 4L &&
++ at.c()[0] == '5' &&
++ at.f()[0] == 6.0f &&
++ at.d()[0] == 7.0 &&
++ at.bool()[0] == true &&
++ at.str()[0].equals("custom") &&
++ at.cls()[0] == Map.class &&
++ at.e()[0] == Stooge.MOE &&
++ at.a()[0].x() == 1 && at.a()[0].y() == 2 &&
++
++ at.b().length==1 && at.s().length==1 && at.i().length==1 &&
++ at.l().length==1 && at.c().length==1 && at.d().length==1 &&
++ at.bool().length==1 && at.str().length==1 &&
++ at.cls().length==1 && at.cls().length==1))
++ fail("ArrayTypesOverrideDefault" + e);
++ }
++
++ static void checkArrayTypesAcceptDefault(AnnotatedElement e) {
++ try {
++ checkArrayTypesAcceptDefault(e.getAnnotation(ArrayTypesWithDefault.class), e);
++ } catch(Throwable t) {
++ fail("ArrayTypesAcceptDefault" + e + ": " + t);
++ }
++ }
++
++ static void checkArrayTypesAcceptDefault(ArrayTypesWithDefault at, AnnotatedElement e) {
++ numTests++;
++ if (!(at.b()[0] == 11 &&
++ at.s()[0] == 12 &&
++ at.i()[0] == 13 &&
++ at.l()[0] == 14L &&
++ at.c()[0] == 'V' &&
++ at.f()[0] == 16.0f &&
++ at.d()[0] == 17.0 &&
++ at.bool()[0] == false &&
++ at.str()[0].equals("default") &&
++ at.cls()[0] == Class.class &&
++ at.e()[0] == Stooge.LARRY &&
++ at.a()[0].x() == 11 && at.a()[0].y() == 12 &&
++
++ at.b().length==1 && at.s().length==1 && at.i().length==1 &&
++ at.l().length==1 && at.c().length==1 && at.d().length==1 &&
++ at.bool().length==1 && at.str().length==1 &&
++ at.cls().length==1 && at.cls().length==1))
++ fail("ArrayTypesAcceptDefault" + e);
++ }
++
++ // Scalar multi-member for parameters
++
++ static void checkScalarTypesParam(Method m) {
++ try {
++ checkScalarTypes((ScalarTypes) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ScalarTypes" + m + ": " + t);
++ }
++ }
++
++ static void checkScalarTypesOverrideDefaultParam(Method m) {
++ try {
++ checkScalarTypesOverrideDefault((ScalarTypesWithDefault) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ScalarTypesOverrideDefaults" + m + ": " + t);
++ }
++ }
++
++ static void checkScalarTypesAcceptDefaultParam(Method m) {
++ try {
++ checkScalarTypesAcceptDefault((ScalarTypesWithDefault) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ScalarTypesAcceptDefaults" + m + ": " + t);
++ }
++ }
++
++ // Array multi-member for parameters
++
++ static void checkArrayTypes0Param(Method m) {
++ try {
++ checkArrayTypes0((ArrayTypes) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ArrayTypes(Empty)" + m + ": " + t);
++ }
++ }
++
++ static void checkArrayTypes1Param(Method m) {
++ try {
++ checkArrayTypes1((ArrayTypes) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ArrayTypes(One Element)" + m + ": " + t);
++ }
++ }
++
++ static void checkArrayTypes2Param(Method m) {
++ try {
++ checkArrayTypes2((ArrayTypes) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ArrayTypes(Two Elements)" + m + ": " + t);
++ }
++ }
++
++ static void checkArrayTypesOverrideDefaultParam(Method m) {
++ try {
++ checkArrayTypesOverrideDefault((ArrayTypesWithDefault) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ArrayTypesOverrideDefault" + m + ": " + t);
++ }
++ }
++
++ static void checkArrayTypesAcceptDefaultParam(Method m) {
++ try {
++ checkArrayTypesAcceptDefault((ArrayTypesWithDefault) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("ArrayTypesAcceptDefault" + m + ": " + t);
++ }
++ }
++
++ // marker type on parameter
++ static void checkMarkerParam(Method m) {
++ try {
++ checkMarker((Marker) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("Marker" + m + ": " + t);
++ }
++ }
++
++ // single-member scalar types on parameter
++ static void checkSingleMemberByteParam(Method m) {
++ try {
++ checkSingleMemberByte((SingleMemberByte) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByte" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortParam(Method m) {
++ try {
++ checkSingleMemberShort((SingleMemberShort) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShort" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntParam(Method m) {
++ try {
++ checkSingleMemberInt((SingleMemberInt) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberInt" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongParam(Method m) {
++ try {
++ checkSingleMemberLong((SingleMemberLong) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLong" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharParam(Method m) {
++ try {
++ checkSingleMemberChar((SingleMemberChar) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberChar" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatParam(Method m) {
++ try {
++ checkSingleMemberFloat((SingleMemberFloat) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloat" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleParam(Method m) {
++ try {
++ checkSingleMemberDouble((SingleMemberDouble) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDouble" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanParam(Method m) {
++ try {
++ checkSingleMemberBoolean((SingleMemberBoolean) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBoolean" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringParam(Method m) {
++ try {
++ checkSingleMemberString((SingleMemberString) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberString" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassParam(Method m) {
++ try {
++ checkSingleMemberClass((SingleMemberClass) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClass" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumParam(Method m) {
++ try {
++ checkSingleMemberEnum((SingleMemberEnum) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnum" + m + ": " + t);
++ }
++ }
++
++ // single-member scalar types with default-override on parameter
++ static void checkSingleMemberByteOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberByteOvrdDef((SingleMemberByteWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByteOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberShortOvrdDef((SingleMemberShortWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShortOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberIntOvrdDef((SingleMemberIntWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberIntOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberLongOvrdDef((SingleMemberLongWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLongOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberCharOvrdDef((SingleMemberCharWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberCharOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberFloatOvrdDef((SingleMemberFloatWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloatOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberDoubleOvrdDef((SingleMemberDoubleWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberBooleanOvrdDef((SingleMemberBooleanWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberStringOvrdDef((SingleMemberStringWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberStringOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberClassOvrdDef((SingleMemberClassWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClassOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberEnumOvrdDef((SingleMemberEnumWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnumOvrdDef" + m + ": " + t);
++ }
++ }
++
++ // single-member scalar types with default-accept on PARAMETER
++ static void checkSingleMemberByteAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberByteAcceptDef((SingleMemberByteWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByteAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberShortAcceptDef((SingleMemberShortWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShortAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberIntAcceptDef((SingleMemberIntWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberIntAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberLongAcceptDef((SingleMemberLongWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLongAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberCharAcceptDef((SingleMemberCharWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberCharAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberFloatAcceptDef((SingleMemberFloatWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloatAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberDoubleAcceptDef((SingleMemberDoubleWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberBooleanAcceptDef((SingleMemberBooleanWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberStringAcceptDef((SingleMemberStringWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberStringAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberClassAcceptDef((SingleMemberClassWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClassAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberEnumAcceptDef((SingleMemberEnumWithDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnumAcceptDef" + m + ": " + t);
++ }
++ }
++
++ // single-member array types (empty array) parameter
++ static void checkSingleMemberByteArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberByteArrEmpty((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberShortArrEmpty((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberIntArrEmpty((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberLongArrEmpty((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberCharArrEmpty((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberFloatArrEmpty((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberDoubleArrEmpty((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberBooleanArrEmpty((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberStringArrEmpty((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberClassArrEmpty((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrEmpty" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrEmptyParam(Method m) {
++ try {
++ checkSingleMemberEnumArrEmpty((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrEmpty" + m + ": " + t);
++ }
++ }
++
++ // single-member array types (one-element array) on parameter
++ static void checkSingleMemberByteArrOneParam(Method m) {
++ try {
++ checkSingleMemberByteArrOne((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrOneParam(Method m) {
++ try {
++ checkSingleMemberShortArrOne((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrOneParam(Method m) {
++ try {
++ checkSingleMemberIntArrOne((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrOneParam(Method m) {
++ try {
++ checkSingleMemberLongArrOne((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrOneParam(Method m) {
++ try {
++ checkSingleMemberCharArrOne((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrOneParam(Method m) {
++ try {
++ checkSingleMemberFloatArrOne((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrOneParam(Method m) {
++ try {
++ checkSingleMemberDoubleArrOne((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrOneParam(Method m) {
++ try {
++ checkSingleMemberBooleanArrOne((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrOneParam(Method m) {
++ try {
++ checkSingleMemberStringArrOne((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrOneParam(Method m) {
++ try {
++ checkSingleMemberClassArrOne((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrOne" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrOneParam(Method m) {
++ try {
++ checkSingleMemberEnumArrOne((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrOne" + m + ": " + t);
++ }
++ }
++
++ // single-member array types (two-element array) on parameter
++ static void checkSingleMemberByteArrTwoParam(Method m) {
++ try {
++ checkSingleMemberByteArrTwo((SingleMemberByteArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrTwoParam(Method m) {
++ try {
++ checkSingleMemberShortArrTwo((SingleMemberShortArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrTwoParam(Method m) {
++ try {
++ checkSingleMemberIntArrTwo((SingleMemberIntArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrTwoParam(Method m) {
++ try {
++ checkSingleMemberLongArrTwo((SingleMemberLongArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrTwoParam(Method m) {
++ try {
++ checkSingleMemberCharArrTwo((SingleMemberCharArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrTwoParam(Method m) {
++ try {
++ checkSingleMemberFloatArrTwo((SingleMemberFloatArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrTwoParam(Method m) {
++ try {
++ checkSingleMemberDoubleArrTwo((SingleMemberDoubleArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrTwoParam(Method m) {
++ try {
++ checkSingleMemberBooleanArrTwo((SingleMemberBooleanArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrTwoParam(Method m) {
++ try {
++ checkSingleMemberStringArrTwo((SingleMemberStringArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrTwoParam(Method m) {
++ try {
++ checkSingleMemberClassArrTwo((SingleMemberClassArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrTwo" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrTwoParam(Method m) {
++ try {
++ checkSingleMemberEnumArrTwo((SingleMemberEnumArray) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrTwo" + m + ": " + t);
++ }
++ }
++
++ // single-member array types with default (override)on parameter
++ static void checkSingleMemberByteArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberByteArrOvrdDef((SingleMemberByteArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberShortArrOvrdDef((SingleMemberShortArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberIntArrOvrdDef((SingleMemberIntArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberLongArrOvrdDef((SingleMemberLongArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberCharArrOvrdDef((SingleMemberCharArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberFloatArrOvrdDef((SingleMemberFloatArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberDoubleArrOvrdDef((SingleMemberDoubleArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberBooleanArrOvrdDef((SingleMemberBooleanArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberStringArrOvrdDef((SingleMemberStringArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberClassArrOvrdDef((SingleMemberClassArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrOvrdDefParam(Method m) {
++ try {
++ checkSingleMemberEnumArrOvrdDef((SingleMemberEnumArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrOvrdDef" + m + ": " + t);
++ }
++ }
++
++ // single-member array types with default (accept)on parameter
++ static void checkSingleMemberByteArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberByteArrAcceptDef((SingleMemberByteArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberShortArrAcceptDef((SingleMemberShortArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberIntArrAcceptDef((SingleMemberIntArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberLongArrAcceptDef((SingleMemberLongArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberCharArrAcceptDef((SingleMemberCharArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberFloatArrAcceptDef((SingleMemberFloatArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberDoubleArrAcceptDef((SingleMemberDoubleArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberBooleanArrAcceptDef((SingleMemberBooleanArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberStringArrAcceptDef((SingleMemberStringArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberClassArrAcceptDef((SingleMemberClassArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrAcceptDefParam(Method m) {
++ try {
++ checkSingleMemberEnumArrAcceptDef((SingleMemberEnumArrayDef) m.getParameterAnnotations()[0][0], m);
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrAcceptDef" + m + ": " + t);
++ }
++ }
++
++ // Marker
++ static void checkMarker(AnnotatedElement e) {
++ checkMarker(e.getAnnotation(Marker.class), e);
++ }
++ static void checkMarker(Marker m, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (m == null) fail("Marker " + e);
++ } catch(Throwable t) {
++ fail("Marker " + e + ": " + t);
++ }
++ }
++
++ // Single-member
++
++ static void checkSingleMemberByte(AnnotatedElement e) {
++ checkSingleMemberByte(e.getAnnotation(SingleMemberByte.class), e);
++ }
++ static void checkSingleMemberByte(SingleMemberByte a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 1) fail("SingleMemberByte " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByte " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShort(AnnotatedElement e) {
++ checkSingleMemberShort(e.getAnnotation(SingleMemberShort.class), e);
++ }
++ static void checkSingleMemberShort(SingleMemberShort a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 2) fail("SingleMemberShort " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShort " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberInt(AnnotatedElement e) {
++ checkSingleMemberInt(e.getAnnotation(SingleMemberInt.class), e);
++ }
++ static void checkSingleMemberInt(SingleMemberInt a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 3) fail("SingleMemberInt " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberInt " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLong(AnnotatedElement e) {
++ checkSingleMemberLong(e.getAnnotation(SingleMemberLong.class), e);
++ }
++ static void checkSingleMemberLong(SingleMemberLong a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 4L) fail("SingleMemberLong " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLong " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberChar(AnnotatedElement e) {
++ checkSingleMemberChar(e.getAnnotation(SingleMemberChar.class), e);
++ }
++ static void checkSingleMemberChar(SingleMemberChar a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != '5') fail("SingleMemberChar " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberChar " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloat(AnnotatedElement e) {
++ checkSingleMemberFloat(e.getAnnotation(SingleMemberFloat.class), e);
++ }
++ static void checkSingleMemberFloat(SingleMemberFloat a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 6.0f) fail("SingleMemberFloat " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloat " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDouble(AnnotatedElement e) {
++ checkSingleMemberDouble(e.getAnnotation(SingleMemberDouble.class), e);
++ }
++ static void checkSingleMemberDouble(SingleMemberDouble a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 7.0) fail("SingleMemberDouble " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDouble " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBoolean(AnnotatedElement e) {
++ checkSingleMemberBoolean(e.getAnnotation(SingleMemberBoolean.class), e);
++ }
++ static void checkSingleMemberBoolean(SingleMemberBoolean a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (!a.value()) fail("SingleMemberBoolean " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBoolean " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberString(AnnotatedElement e) {
++ checkSingleMemberString(e.getAnnotation(SingleMemberString.class), e);
++ }
++ static void checkSingleMemberString(SingleMemberString a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (!(a.value().equals("custom"))) fail("SingleMemberString " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberString " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClass(AnnotatedElement e) {
++ checkSingleMemberClass(e.getAnnotation(SingleMemberClass.class), e);
++ }
++ static void checkSingleMemberClass(SingleMemberClass a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != Map.class) fail("SingleMemberClass " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClass " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnum(AnnotatedElement e) {
++ checkSingleMemberEnum(e.getAnnotation(SingleMemberEnum.class), e);
++ }
++ static void checkSingleMemberEnum(SingleMemberEnum a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != Stooge.MOE) fail("SingleMemberEnum " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnum " + e + ": " + t);
++ }
++ }
++
++ // Single-member with default (Override)
++
++ static void checkSingleMemberByteOvrdDef(AnnotatedElement e) {
++ checkSingleMemberByteOvrdDef(e.getAnnotation(SingleMemberByteWithDef.class), e);
++ }
++ static void checkSingleMemberByteOvrdDef(SingleMemberByteWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 1) fail("SingleMemberByteOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByteOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortOvrdDef(AnnotatedElement e) {
++ checkSingleMemberShortOvrdDef(e.getAnnotation(SingleMemberShortWithDef.class), e);
++ }
++ static void checkSingleMemberShortOvrdDef(SingleMemberShortWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 2) fail("SingleMemberShortOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShortOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntOvrdDef(AnnotatedElement e) {
++ checkSingleMemberIntOvrdDef(e.getAnnotation(SingleMemberIntWithDef.class), e);
++ }
++ static void checkSingleMemberIntOvrdDef(SingleMemberIntWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 3) fail("SingleMemberIntOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberIntOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongOvrdDef(AnnotatedElement e) {
++ checkSingleMemberLongOvrdDef(e.getAnnotation(SingleMemberLongWithDef.class), e);
++ }
++ static void checkSingleMemberLongOvrdDef(SingleMemberLongWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 4L) fail("SingleMemberLongOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLongOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharOvrdDef(AnnotatedElement e) {
++ checkSingleMemberCharOvrdDef(e.getAnnotation(SingleMemberCharWithDef.class), e);
++ }
++ static void checkSingleMemberCharOvrdDef(SingleMemberCharWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != '5') fail("SingleMemberCharOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberCharOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatOvrdDef(AnnotatedElement e) {
++ checkSingleMemberFloatOvrdDef(e.getAnnotation(SingleMemberFloatWithDef.class), e);
++ }
++ static void checkSingleMemberFloatOvrdDef(SingleMemberFloatWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 6.0f) fail("SingleMemberFloatOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloatOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleOvrdDef(AnnotatedElement e) {
++ checkSingleMemberDoubleOvrdDef(e.getAnnotation(SingleMemberDoubleWithDef.class), e);
++ }
++ static void checkSingleMemberDoubleOvrdDef(SingleMemberDoubleWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 7.0) fail("SingleMemberDoubleOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanOvrdDef(AnnotatedElement e) {
++ checkSingleMemberBooleanOvrdDef(e.getAnnotation(SingleMemberBooleanWithDef.class), e);
++ }
++ static void checkSingleMemberBooleanOvrdDef(SingleMemberBooleanWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (!a.value()) fail("SingleMemberBooleanOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringOvrdDef(AnnotatedElement e) {
++ checkSingleMemberStringOvrdDef(e.getAnnotation(SingleMemberStringWithDef.class), e);
++ }
++ static void checkSingleMemberStringOvrdDef(SingleMemberStringWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (!(a.value().equals("custom"))) fail("SingleMemberStringOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberStringOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassOvrdDef(AnnotatedElement e) {
++ checkSingleMemberClassOvrdDef(e.getAnnotation(SingleMemberClassWithDef.class), e);
++ }
++ static void checkSingleMemberClassOvrdDef(SingleMemberClassWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != Map.class) fail("SingleMemberClassOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClassOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumOvrdDef(AnnotatedElement e) {
++ checkSingleMemberEnumOvrdDef(e.getAnnotation(SingleMemberEnumWithDef.class), e);
++ }
++ static void checkSingleMemberEnumOvrdDef(SingleMemberEnumWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != Stooge.MOE) fail("SingleMemberEnumOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnumOvrdDef " + e + ": " + t);
++ }
++ }
++
++ // Single-member with default (Accept)
++
++ static void checkSingleMemberByteAcceptDef(AnnotatedElement e) {
++ checkSingleMemberByteAcceptDef(e.getAnnotation(SingleMemberByteWithDef.class), e);
++ }
++ static void checkSingleMemberByteAcceptDef(SingleMemberByteWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 11) fail("SingleMemberByteAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByteAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortAcceptDef(AnnotatedElement e) {
++ checkSingleMemberShortAcceptDef(e.getAnnotation(SingleMemberShortWithDef.class), e);
++ }
++ static void checkSingleMemberShortAcceptDef(SingleMemberShortWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 12) fail("SingleMemberShortAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShortAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntAcceptDef(AnnotatedElement e) {
++ checkSingleMemberIntAcceptDef(e.getAnnotation(SingleMemberIntWithDef.class), e);
++ }
++ static void checkSingleMemberIntAcceptDef(SingleMemberIntWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 13) fail("SingleMemberIntAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberIntAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongAcceptDef(AnnotatedElement e) {
++ checkSingleMemberLongAcceptDef(e.getAnnotation(SingleMemberLongWithDef.class), e);
++ }
++ static void checkSingleMemberLongAcceptDef(SingleMemberLongWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 14L) fail("SingleMemberLongAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLongAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharAcceptDef(AnnotatedElement e) {
++ checkSingleMemberCharAcceptDef(e.getAnnotation(SingleMemberCharWithDef.class), e);
++ }
++ static void checkSingleMemberCharAcceptDef(SingleMemberCharWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 'V') fail("SingleMemberCharAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberCharAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatAcceptDef(AnnotatedElement e) {
++ checkSingleMemberFloatAcceptDef(e.getAnnotation(SingleMemberFloatWithDef.class), e);
++ }
++ static void checkSingleMemberFloatAcceptDef(SingleMemberFloatWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 16.0f) fail("SingleMemberFloatAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloatAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleAcceptDef(AnnotatedElement e) {
++ checkSingleMemberDoubleAcceptDef(e.getAnnotation(SingleMemberDoubleWithDef.class), e);
++ }
++ static void checkSingleMemberDoubleAcceptDef(SingleMemberDoubleWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != 17.0) fail("SingleMemberDoubleAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanAcceptDef(AnnotatedElement e) {
++ checkSingleMemberBooleanAcceptDef(e.getAnnotation(SingleMemberBooleanWithDef.class), e);
++ }
++ static void checkSingleMemberBooleanAcceptDef(SingleMemberBooleanWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value()) fail("SingleMemberBooleanAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringAcceptDef(AnnotatedElement e) {
++ checkSingleMemberStringAcceptDef(e.getAnnotation(SingleMemberStringWithDef.class), e);
++ }
++ static void checkSingleMemberStringAcceptDef(SingleMemberStringWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (!(a.value().equals("default"))) fail("SingleMemberStringAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberStringAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassAcceptDef(AnnotatedElement e) {
++ checkSingleMemberClassAcceptDef(e.getAnnotation(SingleMemberClassWithDef.class), e);
++ }
++ static void checkSingleMemberClassAcceptDef(SingleMemberClassWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != Class.class) fail("SingleMemberClassAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClassAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumAcceptDef(AnnotatedElement e) {
++ checkSingleMemberEnumAcceptDef(e.getAnnotation(SingleMemberEnumWithDef.class), e);
++ }
++ static void checkSingleMemberEnumAcceptDef(SingleMemberEnumWithDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value() != Stooge.LARRY) fail("SingleMemberEnumAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnumAcceptDef " + e + ": " + t);
++ }
++ }
++
++ // Single member array (empty array)
++ static void checkSingleMemberByteArrEmpty(AnnotatedElement e) {
++ checkSingleMemberByteArrEmpty(e.getAnnotation(SingleMemberByteArray.class), e);
++ }
++ static void checkSingleMemberByteArrEmpty(SingleMemberByteArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberByteArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrEmpty(AnnotatedElement e) {
++ checkSingleMemberShortArrEmpty(e.getAnnotation(SingleMemberShortArray.class), e);
++ }
++ static void checkSingleMemberShortArrEmpty(SingleMemberShortArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberShortArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrEmpty(AnnotatedElement e) {
++ checkSingleMemberIntArrEmpty(e.getAnnotation(SingleMemberIntArray.class), e);
++ }
++ static void checkSingleMemberIntArrEmpty(SingleMemberIntArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberIntArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrEmpty(AnnotatedElement e) {
++ checkSingleMemberLongArrEmpty(e.getAnnotation(SingleMemberLongArray.class), e);
++ }
++ static void checkSingleMemberLongArrEmpty(SingleMemberLongArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberLongArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrEmpty(AnnotatedElement e) {
++ checkSingleMemberCharArrEmpty(e.getAnnotation(SingleMemberCharArray.class), e);
++ }
++ static void checkSingleMemberCharArrEmpty(SingleMemberCharArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberCharArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrEmpty(AnnotatedElement e) {
++ checkSingleMemberFloatArrEmpty(e.getAnnotation(SingleMemberFloatArray.class), e);
++ }
++ static void checkSingleMemberFloatArrEmpty(SingleMemberFloatArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberFloatArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrEmpty(AnnotatedElement e) {
++ checkSingleMemberDoubleArrEmpty(e.getAnnotation(SingleMemberDoubleArray.class), e);
++ }
++ static void checkSingleMemberDoubleArrEmpty(SingleMemberDoubleArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberDoubleArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrEmpty(AnnotatedElement e) {
++ checkSingleMemberBooleanArrEmpty(e.getAnnotation(SingleMemberBooleanArray.class), e);
++ }
++ static void checkSingleMemberBooleanArrEmpty(SingleMemberBooleanArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberBooleanArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrEmpty(AnnotatedElement e) {
++ checkSingleMemberStringArrEmpty(e.getAnnotation(SingleMemberStringArray.class), e);
++ }
++ static void checkSingleMemberStringArrEmpty(SingleMemberStringArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberStringArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrEmpty(AnnotatedElement e) {
++ checkSingleMemberClassArrEmpty(e.getAnnotation(SingleMemberClassArray.class), e);
++ }
++ static void checkSingleMemberClassArrEmpty(SingleMemberClassArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberClassArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrEmpty " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrEmpty(AnnotatedElement e) {
++ checkSingleMemberEnumArrEmpty(e.getAnnotation(SingleMemberEnumArray.class), e);
++ }
++ static void checkSingleMemberEnumArrEmpty(SingleMemberEnumArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 0) fail("SingleMemberEnumArrEmpty " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrEmpty " + e + ": " + t);
++ }
++ }
++
++ // Single member array (one element array)
++ static void checkSingleMemberByteArrOne(AnnotatedElement e) {
++ checkSingleMemberByteArrOne(e.getAnnotation(SingleMemberByteArray.class), e);
++ }
++ static void checkSingleMemberByteArrOne(SingleMemberByteArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != (byte)1)
++ fail("SingleMemberByteArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrOne(AnnotatedElement e) {
++ checkSingleMemberShortArrOne(e.getAnnotation(SingleMemberShortArray.class), e);
++ }
++ static void checkSingleMemberShortArrOne(SingleMemberShortArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != (short)2)
++ fail("SingleMemberShortArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrOne(AnnotatedElement e) {
++ checkSingleMemberIntArrOne(e.getAnnotation(SingleMemberIntArray.class), e);
++ }
++ static void checkSingleMemberIntArrOne(SingleMemberIntArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 3)
++ fail("SingleMemberIntArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrOne(AnnotatedElement e) {
++ checkSingleMemberLongArrOne(e.getAnnotation(SingleMemberLongArray.class), e);
++ }
++ static void checkSingleMemberLongArrOne(SingleMemberLongArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 4L)
++ fail("SingleMemberLongArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrOne(AnnotatedElement e) {
++ checkSingleMemberCharArrOne(e.getAnnotation(SingleMemberCharArray.class), e);
++ }
++ static void checkSingleMemberCharArrOne(SingleMemberCharArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != '5')
++ fail("SingleMemberCharArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrOne(AnnotatedElement e) {
++ checkSingleMemberFloatArrOne(e.getAnnotation(SingleMemberFloatArray.class), e);
++ }
++ static void checkSingleMemberFloatArrOne(SingleMemberFloatArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 6.0f)
++ fail("SingleMemberFloatArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrOne(AnnotatedElement e) {
++ checkSingleMemberDoubleArrOne(e.getAnnotation(SingleMemberDoubleArray.class), e);
++ }
++ static void checkSingleMemberDoubleArrOne(SingleMemberDoubleArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 7.0)
++ fail("SingleMemberDoubleArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrOne(AnnotatedElement e) {
++ checkSingleMemberBooleanArrOne(e.getAnnotation(SingleMemberBooleanArray.class), e);
++ }
++ static void checkSingleMemberBooleanArrOne(SingleMemberBooleanArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || !a.value()[0])
++ fail("SingleMemberBooleanArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrOne(AnnotatedElement e) {
++ checkSingleMemberStringArrOne(e.getAnnotation(SingleMemberStringArray.class), e);
++ }
++ static void checkSingleMemberStringArrOne(SingleMemberStringArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || !(a.value()[0].equals("custom")))
++ fail("SingleMemberStringArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrOne(AnnotatedElement e) {
++ checkSingleMemberClassArrOne(e.getAnnotation(SingleMemberClassArray.class), e);
++ }
++ static void checkSingleMemberClassArrOne(SingleMemberClassArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != Map.class)
++ fail("SingleMemberClassArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrOne " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrOne(AnnotatedElement e) {
++ checkSingleMemberEnumArrOne(e.getAnnotation(SingleMemberEnumArray.class), e);
++ }
++ static void checkSingleMemberEnumArrOne(SingleMemberEnumArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != Stooge.MOE)
++ fail("SingleMemberEnumArrOne " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrOne " + e + ": " + t);
++ }
++ }
++
++ // Single member array (two element array)
++ static void checkSingleMemberByteArrTwo(AnnotatedElement e) {
++ checkSingleMemberByteArrTwo(e.getAnnotation(SingleMemberByteArray.class), e);
++ }
++ static void checkSingleMemberByteArrTwo(SingleMemberByteArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != (byte)1 || a.value()[1] != (byte)2)
++ fail("SingleMemberByteArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrTwo(AnnotatedElement e) {
++ checkSingleMemberShortArrTwo(e.getAnnotation(SingleMemberShortArray.class), e);
++ }
++ static void checkSingleMemberShortArrTwo(SingleMemberShortArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != (short)2 || a.value()[1] != (short)3)
++ fail("SingleMemberShortArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrTwo(AnnotatedElement e) {
++ checkSingleMemberIntArrTwo(e.getAnnotation(SingleMemberIntArray.class), e);
++ }
++ static void checkSingleMemberIntArrTwo(SingleMemberIntArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != 3 || a.value()[1] != 4)
++ fail("SingleMemberIntArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrTwo(AnnotatedElement e) {
++ checkSingleMemberLongArrTwo(e.getAnnotation(SingleMemberLongArray.class), e);
++ }
++ static void checkSingleMemberLongArrTwo(SingleMemberLongArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != 4L || a.value()[1] != 5L)
++ fail("SingleMemberLongArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrTwo(AnnotatedElement e) {
++ checkSingleMemberCharArrTwo(e.getAnnotation(SingleMemberCharArray.class), e);
++ }
++ static void checkSingleMemberCharArrTwo(SingleMemberCharArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != '5' || a.value()[1] != '6')
++ fail("SingleMemberCharArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrTwo(AnnotatedElement e) {
++ checkSingleMemberFloatArrTwo(e.getAnnotation(SingleMemberFloatArray.class), e);
++ }
++ static void checkSingleMemberFloatArrTwo(SingleMemberFloatArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != 6.0f || a.value()[1] != 7.0f)
++ fail("SingleMemberFloatArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrTwo(AnnotatedElement e) {
++ checkSingleMemberDoubleArrTwo(e.getAnnotation(SingleMemberDoubleArray.class), e);
++ }
++ static void checkSingleMemberDoubleArrTwo(SingleMemberDoubleArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != 7.0 || a.value()[1] != 8.0)
++ fail("SingleMemberDoubleArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrTwo(AnnotatedElement e) {
++ checkSingleMemberBooleanArrTwo(e.getAnnotation(SingleMemberBooleanArray.class), e);
++ }
++ static void checkSingleMemberBooleanArrTwo(SingleMemberBooleanArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || !a.value()[0] || a.value()[1])
++ fail("SingleMemberBooleanArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrTwo(AnnotatedElement e) {
++ checkSingleMemberStringArrTwo(e.getAnnotation(SingleMemberStringArray.class), e);
++ }
++ static void checkSingleMemberStringArrTwo(SingleMemberStringArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || !(a.value()[0].equals("custom")) || !(a.value()[1].equals("paint")))
++ fail("SingleMemberStringArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrTwo(AnnotatedElement e) {
++ checkSingleMemberClassArrTwo(e.getAnnotation(SingleMemberClassArray.class), e);
++ }
++ static void checkSingleMemberClassArrTwo(SingleMemberClassArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != Map.class || a.value()[1] != Set.class)
++ fail("SingleMemberClassArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrTwo " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrTwo(AnnotatedElement e) {
++ checkSingleMemberEnumArrTwo(e.getAnnotation(SingleMemberEnumArray.class), e);
++ }
++ static void checkSingleMemberEnumArrTwo(SingleMemberEnumArray a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 2 || a.value()[0] != Stooge.MOE || a.value()[1] != Stooge.CURLY)
++ fail("SingleMemberEnumArrTwo " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrTwo " + e + ": " + t);
++ }
++ }
++
++ // Single member array with default (override)
++ static void checkSingleMemberByteArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberByteArrOvrdDef(e.getAnnotation(SingleMemberByteArrayDef.class), e);
++ }
++ static void checkSingleMemberByteArrOvrdDef(SingleMemberByteArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != (byte)1)
++ fail("SingleMemberByteArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberShortArrOvrdDef(e.getAnnotation(SingleMemberShortArrayDef.class), e);
++ }
++ static void checkSingleMemberShortArrOvrdDef(SingleMemberShortArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != (short)2)
++ fail("SingleMemberShortArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberIntArrOvrdDef(e.getAnnotation(SingleMemberIntArrayDef.class), e);
++ }
++ static void checkSingleMemberIntArrOvrdDef(SingleMemberIntArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 3)
++ fail("SingleMemberIntArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberLongArrOvrdDef(e.getAnnotation(SingleMemberLongArrayDef.class), e);
++ }
++ static void checkSingleMemberLongArrOvrdDef(SingleMemberLongArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 4L)
++ fail("SingleMemberLongArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberCharArrOvrdDef(e.getAnnotation(SingleMemberCharArrayDef.class), e);
++ }
++ static void checkSingleMemberCharArrOvrdDef(SingleMemberCharArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != '5')
++ fail("SingleMemberCharArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberFloatArrOvrdDef(e.getAnnotation(SingleMemberFloatArrayDef.class), e);
++ }
++ static void checkSingleMemberFloatArrOvrdDef(SingleMemberFloatArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 6.0f)
++ fail("SingleMemberFloatArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberDoubleArrOvrdDef(e.getAnnotation(SingleMemberDoubleArrayDef.class), e);
++ }
++ static void checkSingleMemberDoubleArrOvrdDef(SingleMemberDoubleArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 7.0)
++ fail("SingleMemberDoubleArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberBooleanArrOvrdDef(e.getAnnotation(SingleMemberBooleanArrayDef.class), e);
++ }
++ static void checkSingleMemberBooleanArrOvrdDef(SingleMemberBooleanArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || !a.value()[0])
++ fail("SingleMemberBooleanArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberStringArrOvrdDef(e.getAnnotation(SingleMemberStringArrayDef.class), e);
++ }
++ static void checkSingleMemberStringArrOvrdDef(SingleMemberStringArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || !(a.value()[0].equals("custom")))
++ fail("SingleMemberStringArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberClassArrOvrdDef(e.getAnnotation(SingleMemberClassArrayDef.class), e);
++ }
++ static void checkSingleMemberClassArrOvrdDef(SingleMemberClassArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != Map.class)
++ fail("SingleMemberClassArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrOvrdDef(AnnotatedElement e) {
++ checkSingleMemberEnumArrOvrdDef(e.getAnnotation(SingleMemberEnumArrayDef.class), e);
++ }
++ static void checkSingleMemberEnumArrOvrdDef(SingleMemberEnumArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != Stooge.MOE)
++ fail("SingleMemberEnumArrOvrdDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrOvrdDef " + e + ": " + t);
++ }
++ }
++
++ // Single member array with default (accept)
++ static void checkSingleMemberByteArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberByteArrAcceptDef(e.getAnnotation(SingleMemberByteArrayDef.class), e);
++ }
++ static void checkSingleMemberByteArrAcceptDef(SingleMemberByteArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != (byte)11)
++ fail("SingleMemberByteArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberByteArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberShortArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberShortArrAcceptDef(e.getAnnotation(SingleMemberShortArrayDef.class), e);
++ }
++ static void checkSingleMemberShortArrAcceptDef(SingleMemberShortArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != (short)12)
++ fail("SingleMemberShortArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberShortArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberIntArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberIntArrAcceptDef(e.getAnnotation(SingleMemberIntArrayDef.class), e);
++ }
++ static void checkSingleMemberIntArrAcceptDef(SingleMemberIntArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 13)
++ fail("SingleMemberIntArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberIntArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberLongArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberLongArrAcceptDef(e.getAnnotation(SingleMemberLongArrayDef.class), e);
++ }
++ static void checkSingleMemberLongArrAcceptDef(SingleMemberLongArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 14L)
++ fail("SingleMemberLongArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberLongArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberCharArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberCharArrAcceptDef(e.getAnnotation(SingleMemberCharArrayDef.class), e);
++ }
++ static void checkSingleMemberCharArrAcceptDef(SingleMemberCharArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 'V')
++ fail("SingleMemberCharArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberCharArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberFloatArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberFloatArrAcceptDef(e.getAnnotation(SingleMemberFloatArrayDef.class), e);
++ }
++ static void checkSingleMemberFloatArrAcceptDef(SingleMemberFloatArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 16.0f)
++ fail("SingleMemberFloatArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberFloatArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberDoubleArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberDoubleArrAcceptDef(e.getAnnotation(SingleMemberDoubleArrayDef.class), e);
++ }
++ static void checkSingleMemberDoubleArrAcceptDef(SingleMemberDoubleArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != 17.0)
++ fail("SingleMemberDoubleArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberDoubleArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberBooleanArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberBooleanArrAcceptDef(e.getAnnotation(SingleMemberBooleanArrayDef.class), e);
++ }
++ static void checkSingleMemberBooleanArrAcceptDef(SingleMemberBooleanArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0])
++ fail("SingleMemberBooleanArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberBooleanArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberStringArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberStringArrAcceptDef(e.getAnnotation(SingleMemberStringArrayDef.class), e);
++ }
++ static void checkSingleMemberStringArrAcceptDef(SingleMemberStringArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || !(a.value()[0].equals("default")))
++ fail("SingleMemberStringArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberStringArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberClassArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberClassArrAcceptDef(e.getAnnotation(SingleMemberClassArrayDef.class), e);
++ }
++ static void checkSingleMemberClassArrAcceptDef(SingleMemberClassArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != Class.class)
++ fail("SingleMemberClassArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberClassArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ static void checkSingleMemberEnumArrAcceptDef(AnnotatedElement e) {
++ checkSingleMemberEnumArrAcceptDef(e.getAnnotation(SingleMemberEnumArrayDef.class), e);
++ }
++ static void checkSingleMemberEnumArrAcceptDef(SingleMemberEnumArrayDef a, AnnotatedElement e) {
++ numTests++;
++ try {
++ if (a.value().length != 1 || a.value()[0] != Stooge.LARRY)
++ fail("SingleMemberEnumArrAcceptDef " + e + " = " + a.value());
++ } catch(Throwable t) {
++ fail("SingleMemberEnumArrAcceptDef " + e + ": " + t);
++ }
++ }
++
++ // Verfification methods for equals/hashCode/serialization
++
++ static <T extends Annotation> void checkEquals(AnnotatedElement e1, AnnotatedElement e2, Class<T> annoType) {
++ numTests++;
++ T a1 = e1.getAnnotation(annoType);
++ T a2 = e2.getAnnotation(annoType);
++ try {
++ if (!a1.equals(a2))
++ fail(a1 + " != " + a2);
++ if (a1.hashCode() != a2.hashCode())
++ fail(a1 + ".hashCode() [" + a1.hashCode() + "] != " + a2 + " .hashCode()["+ a2.hashCode()+"]");
++ if (!(a1.toString().equals(a2.toString())))
++ fail(a1 + ".toString() != " + a2 + ".toString()");
++ } catch(Throwable t) {
++ fail(a1 + " == " + a2 + ": " + t);
++ }
++ }
++
++ static <T extends Annotation> void checkUnequals(AnnotatedElement e1, AnnotatedElement e2, Class<T> annoType) {
++ numTests++;
++ T a1 = e1.getAnnotation(annoType);
++ T a2 = e2.getAnnotation(annoType);
++ try {
++ if (a1.equals(a2))
++ fail(a1 + " == " + a2);
++ if (a1.hashCode() == a2.hashCode())
++ fail(a1 + ".hashCode() [" + a1.hashCode() + "] == " + a2 + " .hashCode()[" + a2.hashCode() + "]");
++ if (a1.toString().equals(a2.toString()))
++ fail(a1 + ".toString() == " + a2 + ".toString()");
++ } catch(Throwable t) {
++ fail(a1 + " != " + a2 + ": " + t);
++ }
++ }
++
++ // Verfification method for serialization/deserialization
++
++ static <T extends Annotation> void checkSerialization(AnnotatedElement e, Class<T> annoType) {
++ numTests++;
++ T a1 = e.getAnnotation(annoType);
++ Object a2 = deepCopy(a1);
++ try {
++ if (!a1.equals(a2))
++ fail("Serialization: " + a1 + " != " + a2);
++ if (a1.hashCode() != a2.hashCode())
++ fail("Serialization: " + a1 + ".hashCode() [" + a1.hashCode() + "] != " + a2 + " .hashCode()["+a2.hashCode()+"]");
++ if (!(a1.toString().equals(a2.toString())))
++ fail("Serialization: " + a1 + ".toString() != " + a2 + ".toString()");
++ } catch(Throwable t) {
++ fail("Serialization: " + a1 + " == " + a2 + ": " + t);
++ }
++ }
++
++ private static Object deepCopy(Object original) {
++ try {
++ ByteArrayOutputStream bos = new ByteArrayOutputStream();
++ ObjectOutputStream oos = new ObjectOutputStream(bos);
++ oos.writeObject(original);
++ oos.flush();
++ ByteArrayInputStream bin = new ByteArrayInputStream(
++ bos.toByteArray());
++ ObjectInputStream ois = new ObjectInputStream(bin);
++ return ois.readObject();
++ } catch(Exception e) {
++ throw new IllegalArgumentException(e);
++ }
++ }
++
++ // Verification method for inheritance test
++ static void checkInheritence(AnnotatedElement e, boolean shouldHaveFoo, boolean shouldHaveBar) {
++ numTests++;
++ try {
++ boolean hasFoo = e.isAnnotationPresent(Foo.class);
++ boolean hasBar = e.isAnnotationPresent(Bar.class);
++ if (hasFoo != shouldHaveFoo || hasBar != shouldHaveBar)
++ fail("Inheritance(1): " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar);
++
++ // Now test getAnnotations
++ hasFoo = hasBar = false;
++ Annotation[] allAnnotations = e.getAnnotations();
++ for (Annotation a : allAnnotations) {
++ if (a instanceof Foo)
++ hasFoo = true;
++ else if (a instanceof Bar)
++ hasBar = true;
++ }
++ if (hasFoo != shouldHaveFoo ||hasBar != shouldHaveBar)
++ fail("Inheritance(2): " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar);
++ } catch(Throwable t) {
++ fail("Inheritance: " + e +": " + t);
++ }
++ }
++
++ // Verification method for declared annotations test
++ static void checkDeclaredAnnotations(AnnotatedElement e, boolean shouldHaveFoo, boolean shouldHaveBar) {
++ numTests++;
++ try {
++ boolean hasFoo = false;
++ boolean hasBar = false;
++ Annotation[] declaredAnnotations = e.getDeclaredAnnotations();
++ for (Annotation a : declaredAnnotations) {
++ if (a instanceof Foo)
++ hasFoo = true;
++ else if (a instanceof Bar)
++ hasBar = true;
++ }
++ if (hasFoo != shouldHaveFoo ||hasBar != shouldHaveBar)
++ fail("Declared annotations: " + e +" - Foo: " + hasFoo + ", Bar: " + hasBar);
++ } catch(Throwable t) {
++ fail("Declared annotations: " + e +": " + t);
++ }
++ }
++
++
++ // ANNOTATED METHODS
++
++ @ScalarTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ public void scalarTypesMethod() { }
++
++ @ScalarTypesWithDefault ( )
++ public void scalarTypesAcceptDefaultMethod() { }
++
++ @ScalarTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE
++ )
++ public void scalarTypesOverrideDefaultMethod() { }
++
++ @ArrayTypes (
++ b = { },
++ s = { },
++ i = { },
++ l = { },
++ c = { },
++ f = { },
++ d = { },
++ bool = { },
++ str = { },
++ cls = { },
++ e = { },
++ a = { }
++ )
++ public void emptyArrayTypesMethod() { }
++
++ @ArrayTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = { @Point(x = 1, y = 2) }
++ )
++ public void singleElementArrayTypesMethod() { }
++
++ @ArrayTypes (
++ b = { 1, 2 },
++ s = { 2, 3 },
++ i = { 3, 4 },
++ l = { 4L, 5L },
++ c = { '5', '6' },
++ f = { 6.0f, 7.0f },
++ d = { 7.0, 8.0 },
++ bool = { true, false },
++ str = { "custom", "paint" },
++ cls = { Map.class, Set.class },
++ e = { Stooge.MOE, Stooge.CURLY },
++ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
++ )
++ public void twoElementArrayTypesMethod() { }
++
++ @ArrayTypesWithDefault (
++ )
++ public void arrayTypesAcceptDefaultMethod() { }
++
++ @ArrayTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = { @Point(x = 1, y = 2) }
++ )
++ public void arrayTypesOverrideDefaultMethod() { }
++
++ // Marker
++ @Marker public void markerMethod() { }
++
++ // Single-member (shorthand)
++ @SingleMemberByte(1) public void SingleMemberByte() {}
++ @SingleMemberShort(2) public void SingleMemberShort() {}
++ @SingleMemberInt(3) public void SingleMemberInt() {}
++ @SingleMemberLong(4L) public void SingleMemberLong() {}
++ @SingleMemberChar('5') public void SingleMemberChar() {}
++ @SingleMemberFloat(6.0f) public void SingleMemberFloat() {}
++ @SingleMemberDouble(7.0) public void SingleMemberDouble() {}
++ @SingleMemberBoolean(true) public void SingleMemberBoolean() {}
++ @SingleMemberString("custom") public void SingleMemberString() {}
++ @SingleMemberClass(Map.class) public void SingleMemberClass() {}
++ @SingleMemberEnum(Stooge.MOE) public void SingleMemberEnum() {}
++
++ // Single-member with default (Override)
++ @SingleMemberByteWithDef(1) public void SingleMemberByteOvrdDef() {}
++ @SingleMemberShortWithDef(2) public void SingleMemberShortOvrdDef() {}
++ @SingleMemberIntWithDef(3) public void SingleMemberIntOvrdDef() {}
++ @SingleMemberLongWithDef(4L) public void SingleMemberLongOvrdDef() {}
++ @SingleMemberCharWithDef('5') public void SingleMemberCharOvrdDef() {}
++ @SingleMemberFloatWithDef(6.0f) public void SingleMemberFloatOvrdDef() {}
++ @SingleMemberDoubleWithDef(7.0) public void SingleMemberDoubleOvrdDef() {}
++ @SingleMemberBooleanWithDef(true) public void SingleMemberBooleanOvrdDef() {}
++ @SingleMemberStringWithDef("custom") public void SingleMemberStringOvrdDef() {}
++ @SingleMemberClassWithDef(Map.class) public void SingleMemberClassOvrdDef() {}
++ @SingleMemberEnumWithDef(Stooge.MOE) public void SingleMemberEnumOvrdDef() {}
++
++ // Single-member with default (Accept)
++ @SingleMemberByteWithDef public void SingleMemberByteAcceptDef() {}
++ @SingleMemberShortWithDef public void SingleMemberShortAcceptDef() {}
++ @SingleMemberIntWithDef public void SingleMemberIntAcceptDef() {}
++ @SingleMemberLongWithDef public void SingleMemberLongAcceptDef() {}
++ @SingleMemberCharWithDef public void SingleMemberCharAcceptDef() {}
++ @SingleMemberFloatWithDef public void SingleMemberFloatAcceptDef() {}
++ @SingleMemberDoubleWithDef public void SingleMemberDoubleAcceptDef() {}
++ @SingleMemberBooleanWithDef public void SingleMemberBooleanAcceptDef() {}
++ @SingleMemberStringWithDef public void SingleMemberStringAcceptDef() {}
++ @SingleMemberClassWithDef public void SingleMemberClassAcceptDef() {}
++ @SingleMemberEnumWithDef public void SingleMemberEnumAcceptDef() {}
++
++ // Single member array (empty array)
++ @SingleMemberByteArray({}) public void SingleMemberByteArrEmpty() {}
++ @SingleMemberShortArray({}) public void SingleMemberShortArrEmpty() {}
++ @SingleMemberIntArray({}) public void SingleMemberIntArrEmpty() {}
++ @SingleMemberLongArray({}) public void SingleMemberLongArrEmpty() {}
++ @SingleMemberCharArray({}) public void SingleMemberCharArrEmpty() {}
++ @SingleMemberFloatArray({}) public void SingleMemberFloatArrEmpty() {}
++ @SingleMemberDoubleArray({}) public void SingleMemberDoubleArrEmpty() {}
++ @SingleMemberBooleanArray({})public void SingleMemberBooleanArrEmpty() {}
++ @SingleMemberStringArray({}) public void SingleMemberStringArrEmpty() {}
++ @SingleMemberClassArray({}) public void SingleMemberClassArrEmpty() {}
++ @SingleMemberEnumArray({}) public void SingleMemberEnumArrEmpty() {}
++
++ // Single member array (one-element shorthand)
++ @SingleMemberByteArray(1) public void SingleMemberByteArrOne() {}
++ @SingleMemberShortArray(2) public void SingleMemberShortArrOne() {}
++ @SingleMemberIntArray(3) public void SingleMemberIntArrOne() {}
++ @SingleMemberLongArray(4L) public void SingleMemberLongArrOne() {}
++ @SingleMemberCharArray('5') public void SingleMemberCharArrOne() {}
++ @SingleMemberFloatArray(6.0f) public void SingleMemberFloatArrOne() {}
++ @SingleMemberDoubleArray(7.0) public void SingleMemberDoubleArrOne() {}
++ @SingleMemberBooleanArray(true) public void SingleMemberBooleanArrOne() {}
++ @SingleMemberStringArray("custom") public void SingleMemberStringArrOne() {}
++ @SingleMemberClassArray(Map.class) public void SingleMemberClassArrOne() {}
++ @SingleMemberEnumArray(Stooge.MOE) public void SingleMemberEnumArrOne() {}
++
++ // Single member array (two elements)
++ @SingleMemberByteArray({1, 2}) public void SingleMemberByteArrTwo() {}
++ @SingleMemberShortArray({2, 3}) public void SingleMemberShortArrTwo() {}
++ @SingleMemberIntArray({3, 4}) public void SingleMemberIntArrTwo() {}
++ @SingleMemberLongArray({4L, 5L}) public void SingleMemberLongArrTwo() {}
++ @SingleMemberCharArray({'5', '6'}) public void SingleMemberCharArrTwo() {}
++ @SingleMemberFloatArray({6.0f, 7.0f}) public void SingleMemberFloatArrTwo() {}
++ @SingleMemberDoubleArray({7.0, 8.0}) public void SingleMemberDoubleArrTwo() {}
++ @SingleMemberBooleanArray({true, false}) public void SingleMemberBooleanArrTwo(){}
++ @SingleMemberStringArray({"custom", "paint"}) public void SingleMemberStringArrTwo(){}
++ @SingleMemberClassArray({Map.class, Set.class}) public void SingleMemberClassArrTwo() {}
++ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public void SingleMemberEnumArrTwo() {}
++
++ // Single member array with default (override)
++ @SingleMemberByteArrayDef(1) public void SingleMemberByteArrOvrdDef() {}
++ @SingleMemberShortArrayDef(2) public void SingleMemberShortArrOvrdDef() {}
++ @SingleMemberIntArrayDef(3) public void SingleMemberIntArrOvrdDef() {}
++ @SingleMemberLongArrayDef(4L) public void SingleMemberLongArrOvrdDef() {}
++ @SingleMemberCharArrayDef('5') public void SingleMemberCharArrOvrdDef() {}
++ @SingleMemberFloatArrayDef(6.0f) public void SingleMemberFloatArrOvrdDef() {}
++ @SingleMemberDoubleArrayDef(7.0) public void SingleMemberDoubleArrOvrdDef() {}
++ @SingleMemberBooleanArrayDef(true) public void SingleMemberBooleanArrOvrdDef(){}
++ @SingleMemberStringArrayDef("custom") public void SingleMemberStringArrOvrdDef() {}
++ @SingleMemberClassArrayDef(Map.class) public void SingleMemberClassArrOvrdDef() {}
++ @SingleMemberEnumArrayDef(Stooge.MOE) public void SingleMemberEnumArrOvrdDef() {}
++
++ // Single member array with default - accept
++ @SingleMemberByteArrayDef public void SingleMemberByteArrAcceptDef() {}
++ @SingleMemberShortArrayDef public void SingleMemberShortArrAcceptDef() {}
++ @SingleMemberIntArrayDef public void SingleMemberIntArrAcceptDef() {}
++ @SingleMemberLongArrayDef public void SingleMemberLongArrAcceptDef() {}
++ @SingleMemberCharArrayDef public void SingleMemberCharArrAcceptDef() {}
++ @SingleMemberFloatArrayDef public void SingleMemberFloatArrAcceptDef() {}
++ @SingleMemberDoubleArrayDef public void SingleMemberDoubleArrAcceptDef() {}
++ @SingleMemberBooleanArrayDef public void SingleMemberBooleanArrAcceptDef() {}
++ @SingleMemberStringArrayDef public void SingleMemberStringArrAcceptDef() {}
++ @SingleMemberClassArrayDef public void SingleMemberClassArrAcceptDef() {}
++ @SingleMemberEnumArrayDef public void SingleMemberEnumArrAcceptDef() {}
++
++ // ANNOTATED FIELDS
++ @ScalarTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ public int scalarTypesField;
++
++ @ScalarTypesWithDefault ( )
++ public int scalarTypesAcceptDefaultField;
++
++ @ScalarTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE
++ )
++ public int scalarTypesOverrideDefaultField;
++
++ @ArrayTypes (
++ b = { },
++ s = { },
++ i = { },
++ l = { },
++ c = { },
++ f = { },
++ d = { },
++ bool = { },
++ str = { },
++ cls = { },
++ e = { },
++ a = { }
++ )
++ public int emptyArrayTypesField;
++
++ @ArrayTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = { @Point(x = 1, y = 2) }
++ )
++ public int singleElementArrayTypesField;
++
++ @ArrayTypes (
++ b = { 1, 2 },
++ s = { 2, 3 },
++ i = { 3, 4 },
++ l = { 4L, 5L },
++ c = { '5', '6' },
++ f = { 6.0f, 7.0f },
++ d = { 7.0, 8.0 },
++ bool = { true, false },
++ str = { "custom", "paint" },
++ cls = { Map.class, Set.class },
++ e = { Stooge.MOE, Stooge.CURLY },
++ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
++ )
++ public int twoElementArrayTypesField;
++
++ @ArrayTypesWithDefault ( )
++ public int arrayTypesAcceptDefaultField;
++
++ @ArrayTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = { @Point(x = 1, y = 2) }
++ )
++ public int arrayTypesOverrideDefaultField;
++
++ @Marker public int markerField;
++
++ // Single-member (shorthand)
++ @SingleMemberByte(1) public int SingleMemberByteField;
++ @SingleMemberShort(2) public int SingleMemberShortField;
++ @SingleMemberInt(3) public int SingleMemberIntField;
++ @SingleMemberLong(4L) public int SingleMemberLongField;
++ @SingleMemberChar('5') public int SingleMemberCharField;
++ @SingleMemberFloat(6.0f) public int SingleMemberFloatField;
++ @SingleMemberDouble(7.0) public int SingleMemberDoubleField;
++ @SingleMemberBoolean(true) public int SingleMemberBooleanField;
++ @SingleMemberString("custom") public int SingleMemberStringField;
++ @SingleMemberClass(Map.class) public int SingleMemberClassField;
++ @SingleMemberEnum(Stooge.MOE) public int SingleMemberEnumField;
++
++ // Single-member with default (Override)
++ @SingleMemberByteWithDef(1) public int SingleMemberByteOvrdDefField;
++ @SingleMemberShortWithDef(2) public int SingleMemberShortOvrdDefField;
++ @SingleMemberIntWithDef(3) public int SingleMemberIntOvrdDefField;
++ @SingleMemberLongWithDef(4L) public int SingleMemberLongOvrdDefField;
++ @SingleMemberCharWithDef('5') public int SingleMemberCharOvrdDefField;
++ @SingleMemberFloatWithDef(6.0f) public int SingleMemberFloatOvrdDefField;
++ @SingleMemberDoubleWithDef(7.0) public int SingleMemberDoubleOvrdDefField;
++ @SingleMemberBooleanWithDef(true) public int SingleMemberBooleanOvrdDefField;
++ @SingleMemberStringWithDef("custom") public int SingleMemberStringOvrdDefField;
++ @SingleMemberClassWithDef(Map.class) public int SingleMemberClassOvrdDefField;
++ @SingleMemberEnumWithDef(Stooge.MOE) public int SingleMemberEnumOvrdDefField;
++
++ // Single-member with default (Accept)
++ @SingleMemberByteWithDef public int SingleMemberByteAcceptDefField;
++ @SingleMemberShortWithDef public int SingleMemberShortAcceptDefField;
++ @SingleMemberIntWithDef public int SingleMemberIntAcceptDefField;
++ @SingleMemberLongWithDef public int SingleMemberLongAcceptDefField;
++ @SingleMemberCharWithDef public int SingleMemberCharAcceptDefField;
++ @SingleMemberFloatWithDef public int SingleMemberFloatAcceptDefField;
++ @SingleMemberDoubleWithDef public int SingleMemberDoubleAcceptDefField;
++ @SingleMemberBooleanWithDef public int SingleMemberBooleanAcceptDefField;
++ @SingleMemberStringWithDef public int SingleMemberStringAcceptDefField;
++ @SingleMemberClassWithDef public int SingleMemberClassAcceptDefField;
++ @SingleMemberEnumWithDef public int SingleMemberEnumAcceptDefField;
++
++ // Single member array (empty array)
++ @SingleMemberByteArray({}) public int SingleMemberByteArrEmptyField;
++ @SingleMemberShortArray({}) public int SingleMemberShortArrEmptyField;
++ @SingleMemberIntArray({}) public int SingleMemberIntArrEmptyField;
++ @SingleMemberLongArray({}) public int SingleMemberLongArrEmptyField;
++ @SingleMemberCharArray({}) public int SingleMemberCharArrEmptyField;
++ @SingleMemberFloatArray({}) public int SingleMemberFloatArrEmptyField;
++ @SingleMemberDoubleArray({}) public int SingleMemberDoubleArrEmptyField;
++ @SingleMemberBooleanArray({})public int SingleMemberBooleanArrEmptyField;
++ @SingleMemberStringArray({}) public int SingleMemberStringArrEmptyField;
++ @SingleMemberClassArray({}) public int SingleMemberClassArrEmptyField;
++ @SingleMemberEnumArray({}) public int SingleMemberEnumArrEmptyField;
++
++ // Single member array (one-element shorthand)
++ @SingleMemberByteArray(1) public int SingleMemberByteArrOneField;
++ @SingleMemberShortArray(2) public int SingleMemberShortArrOneField;
++ @SingleMemberIntArray(3) public int SingleMemberIntArrOneField;
++ @SingleMemberLongArray(4L) public int SingleMemberLongArrOneField;
++ @SingleMemberCharArray('5') public int SingleMemberCharArrOneField;
++ @SingleMemberFloatArray(6.0f) public int SingleMemberFloatArrOneField;
++ @SingleMemberDoubleArray(7.0) public int SingleMemberDoubleArrOneField;
++ @SingleMemberBooleanArray(true) public int SingleMemberBooleanArrOneField;
++ @SingleMemberStringArray("custom") public int SingleMemberStringArrOneField;
++ @SingleMemberClassArray(Map.class) public int SingleMemberClassArrOneField;
++ @SingleMemberEnumArray(Stooge.MOE) public int SingleMemberEnumArrOneField;
++
++ // Single member array (two elements)
++ @SingleMemberByteArray({1, 2}) public int SingleMemberByteArrTwoField;
++ @SingleMemberShortArray({2, 3}) public int SingleMemberShortArrTwoField;
++ @SingleMemberIntArray({3, 4}) public int SingleMemberIntArrTwoField;
++ @SingleMemberLongArray({4L, 5L}) public int SingleMemberLongArrTwoField;
++ @SingleMemberCharArray({'5', '6'}) public int SingleMemberCharArrTwoField;
++ @SingleMemberFloatArray({6.0f, 7.0f}) public int SingleMemberFloatArrTwoField;
++ @SingleMemberDoubleArray({7.0, 8.0}) public int SingleMemberDoubleArrTwoField;
++ @SingleMemberBooleanArray({true,false}) public int SingleMemberBooleanArrTwoField;
++ @SingleMemberStringArray({"custom", "paint"}) public int SingleMemberStringArrTwoField;
++ @SingleMemberClassArray({Map.class, Set.class}) public int SingleMemberClassArrTwoField;
++ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public int SingleMemberEnumArrTwoField;
++
++ // Single member array with default (override)
++ @SingleMemberByteArrayDef(1) public int SingleMemberByteArrOvrdDefField;
++ @SingleMemberShortArrayDef(2) public int SingleMemberShortArrOvrdDefField;
++ @SingleMemberIntArrayDef(3) public int SingleMemberIntArrOvrdDefField;
++ @SingleMemberLongArrayDef(4L) public int SingleMemberLongArrOvrdDefField;
++ @SingleMemberCharArrayDef('5') public int SingleMemberCharArrOvrdDefField;
++ @SingleMemberFloatArrayDef(6.0f) public int SingleMemberFloatArrOvrdDefField;
++ @SingleMemberDoubleArrayDef(7.0) public int SingleMemberDoubleArrOvrdDefField;
++ @SingleMemberBooleanArrayDef(true) public int SingleMemberBooleanArrOvrdDefField;
++ @SingleMemberStringArrayDef("custom") public int SingleMemberStringArrOvrdDefField;
++ @SingleMemberClassArrayDef(Map.class) public int SingleMemberClassArrOvrdDefField;
++ @SingleMemberEnumArrayDef(Stooge.MOE) public int SingleMemberEnumArrOvrdDefField;
++
++ // Single member array with default - accept
++ @SingleMemberByteArrayDef public int SingleMemberByteArrAcceptDefField;
++ @SingleMemberShortArrayDef public int SingleMemberShortArrAcceptDefField;
++ @SingleMemberIntArrayDef public int SingleMemberIntArrAcceptDefField;
++ @SingleMemberLongArrayDef public int SingleMemberLongArrAcceptDefField;
++ @SingleMemberCharArrayDef public int SingleMemberCharArrAcceptDefField;
++ @SingleMemberFloatArrayDef public int SingleMemberFloatArrAcceptDefField;
++ @SingleMemberDoubleArrayDef public int SingleMemberDoubleArrAcceptDefField;
++ @SingleMemberBooleanArrayDef public int SingleMemberBooleanArrAcceptDefField;
++ @SingleMemberStringArrayDef public int SingleMemberStringArrAcceptDefField;
++ @SingleMemberClassArrayDef public int SingleMemberClassArrAcceptDefField;
++ @SingleMemberEnumArrayDef public int SingleMemberEnumArrAcceptDefField;
++
++ // ANNOTATED ENUM CONSTANTS
++ enum TestType {
++ @ScalarTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ scalarTypesField,
++
++ @ScalarTypesWithDefault ( )
++ scalarTypesAcceptDefaultField,
++
++ @ScalarTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE
++ )
++ scalarTypesOverrideDefaultField,
++
++ @ArrayTypes (
++ b = { },
++ s = { },
++ i = { },
++ l = { },
++ c = { },
++ f = { },
++ d = { },
++ bool = { },
++ str = { },
++ cls = { },
++ e = { },
++ a = { }
++ )
++ emptyArrayTypesField,
++
++ @ArrayTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ singleElementArrayTypesField,
++
++ @ArrayTypes (
++ b = { 1, 2 },
++ s = { 2, 3 },
++ i = { 3, 4 },
++ l = { 4L, 5L },
++ c = { '5', '6' },
++ f = { 6.0f, 7.0f },
++ d = { 7.0, 8.0 },
++ bool = { true, false },
++ str = { "custom", "paint" },
++ cls = { Map.class, Set.class },
++ e = { Stooge.MOE, Stooge.CURLY },
++ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
++ )
++ twoElementArrayTypesField,
++
++ @ArrayTypesWithDefault ( )
++ arrayTypesAcceptDefaultField,
++
++ @ArrayTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = { @Point(x = 1, y = 2) }
++ )
++ arrayTypesOverrideDefaultField,
++
++ // marker
++ @Marker marker,
++
++ // Single-member (shorthand)
++ @SingleMemberByte(1) SingleMemberByte,
++ @SingleMemberShort(2) SingleMemberShort,
++ @SingleMemberInt(3) SingleMemberInt,
++ @SingleMemberLong(4L) SingleMemberLong,
++ @SingleMemberChar('5') SingleMemberChar,
++ @SingleMemberFloat(6.0f) SingleMemberFloat,
++ @SingleMemberDouble(7.0) SingleMemberDouble,
++ @SingleMemberBoolean(true) SingleMemberBoolean,
++ @SingleMemberString("custom") SingleMemberString,
++ @SingleMemberClass(Map.class) SingleMemberClass,
++ @SingleMemberEnum(Stooge.MOE) SingleMemberEnum,
++
++ // Single-member with default (Override)
++ @SingleMemberByteWithDef(1) SingleMemberByteOvrdDef,
++ @SingleMemberShortWithDef(2) SingleMemberShortOvrdDef,
++ @SingleMemberIntWithDef(3) SingleMemberIntOvrdDef,
++ @SingleMemberLongWithDef(4L) SingleMemberLongOvrdDef,
++ @SingleMemberCharWithDef('5') SingleMemberCharOvrdDef,
++ @SingleMemberFloatWithDef(6.0f) SingleMemberFloatOvrdDef,
++ @SingleMemberDoubleWithDef(7.0) SingleMemberDoubleOvrdDef,
++ @SingleMemberBooleanWithDef(true) SingleMemberBooleanOvrdDef,
++ @SingleMemberStringWithDef("custom") SingleMemberStringOvrdDef,
++ @SingleMemberClassWithDef(Map.class) SingleMemberClassOvrdDef,
++ @SingleMemberEnumWithDef(Stooge.MOE) SingleMemberEnumOvrdDef,
++
++ // Single-member with default (Accept)
++ @SingleMemberByteWithDef SingleMemberByteAcceptDef,
++ @SingleMemberShortWithDef SingleMemberShortAcceptDef,
++ @SingleMemberIntWithDef SingleMemberIntAcceptDef,
++ @SingleMemberLongWithDef SingleMemberLongAcceptDef,
++ @SingleMemberCharWithDef SingleMemberCharAcceptDef,
++ @SingleMemberFloatWithDef SingleMemberFloatAcceptDef,
++ @SingleMemberDoubleWithDef SingleMemberDoubleAcceptDef,
++ @SingleMemberBooleanWithDef SingleMemberBooleanAcceptDef,
++ @SingleMemberStringWithDef SingleMemberStringAcceptDef,
++ @SingleMemberClassWithDef SingleMemberClassAcceptDef,
++ @SingleMemberEnumWithDef SingleMemberEnumAcceptDef,
++
++ // Single member array (empty array)
++ @SingleMemberByteArray({}) SingleMemberByteArrEmpty,
++ @SingleMemberShortArray({}) SingleMemberShortArrEmpty,
++ @SingleMemberIntArray({}) SingleMemberIntArrEmpty,
++ @SingleMemberLongArray({}) SingleMemberLongArrEmpty,
++ @SingleMemberCharArray({}) SingleMemberCharArrEmpty,
++ @SingleMemberFloatArray({}) SingleMemberFloatArrEmpty,
++ @SingleMemberDoubleArray({}) SingleMemberDoubleArrEmpty,
++ @SingleMemberBooleanArray({})SingleMemberBooleanArrEmpty,
++ @SingleMemberStringArray({}) SingleMemberStringArrEmpty,
++ @SingleMemberClassArray({}) SingleMemberClassArrEmpty,
++ @SingleMemberEnumArray({}) SingleMemberEnumArrEmpty,
++
++ // Single member array (one-element shorthand)
++ @SingleMemberByteArray(1) SingleMemberByteArrOne,
++ @SingleMemberShortArray(2) SingleMemberShortArrOne,
++ @SingleMemberIntArray(3) SingleMemberIntArrOne,
++ @SingleMemberLongArray(4L) SingleMemberLongArrOne,
++ @SingleMemberCharArray('5') SingleMemberCharArrOne,
++ @SingleMemberFloatArray(6.0f) SingleMemberFloatArrOne,
++ @SingleMemberDoubleArray(7.0) SingleMemberDoubleArrOne,
++ @SingleMemberBooleanArray(true) SingleMemberBooleanArrOne,
++ @SingleMemberStringArray("custom") SingleMemberStringArrOne,
++ @SingleMemberClassArray(Map.class) SingleMemberClassArrOne,
++ @SingleMemberEnumArray(Stooge.MOE) SingleMemberEnumArrOne,
++
++ // Single member array (two elements)
++ @SingleMemberByteArray({1, 2}) SingleMemberByteArrTwo,
++ @SingleMemberShortArray({2, 3}) SingleMemberShortArrTwo,
++ @SingleMemberIntArray({3, 4}) SingleMemberIntArrTwo,
++ @SingleMemberLongArray({4L, 5L}) SingleMemberLongArrTwo,
++ @SingleMemberCharArray({'5', '6'}) SingleMemberCharArrTwo,
++ @SingleMemberFloatArray({6.0f, 7.0f}) SingleMemberFloatArrTwo,
++ @SingleMemberDoubleArray({7.0, 8.0}) SingleMemberDoubleArrTwo,
++ @SingleMemberBooleanArray({true,false}) SingleMemberBooleanArrTwo,
++ @SingleMemberStringArray({"custom", "paint"}) SingleMemberStringArrTwo,
++ @SingleMemberClassArray({Map.class, Set.class}) SingleMemberClassArrTwo,
++ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) SingleMemberEnumArrTwo,
++
++ // Single member array with default (override)
++ @SingleMemberByteArrayDef(1) SingleMemberByteArrOvrdDef,
++ @SingleMemberShortArrayDef(2) SingleMemberShortArrOvrdDef,
++ @SingleMemberIntArrayDef(3) SingleMemberIntArrOvrdDef,
++ @SingleMemberLongArrayDef(4L) SingleMemberLongArrOvrdDef,
++ @SingleMemberCharArrayDef('5') SingleMemberCharArrOvrdDef,
++ @SingleMemberFloatArrayDef(6.0f) SingleMemberFloatArrOvrdDef,
++ @SingleMemberDoubleArrayDef(7.0) SingleMemberDoubleArrOvrdDef,
++ @SingleMemberBooleanArrayDef(true) SingleMemberBooleanArrOvrdDef,
++ @SingleMemberStringArrayDef("custom") SingleMemberStringArrOvrdDef,
++ @SingleMemberClassArrayDef(Map.class) SingleMemberClassArrOvrdDef,
++ @SingleMemberEnumArrayDef(Stooge.MOE) SingleMemberEnumArrOvrdDef,
++
++ // Single member array with default - accept
++ @SingleMemberByteArrayDef SingleMemberByteArrAcceptDef,
++ @SingleMemberShortArrayDef SingleMemberShortArrAcceptDef,
++ @SingleMemberIntArrayDef SingleMemberIntArrAcceptDef,
++ @SingleMemberLongArrayDef SingleMemberLongArrAcceptDef,
++ @SingleMemberCharArrayDef SingleMemberCharArrAcceptDef,
++ @SingleMemberFloatArrayDef SingleMemberFloatArrAcceptDef,
++ @SingleMemberDoubleArrayDef SingleMemberDoubleArrAcceptDef,
++ @SingleMemberBooleanArrayDef SingleMemberBooleanArrAcceptDef,
++ @SingleMemberStringArrayDef SingleMemberStringArrAcceptDef,
++ @SingleMemberClassArrayDef SingleMemberClassArrAcceptDef,
++ @SingleMemberEnumArrayDef SingleMemberEnumArrAcceptDef,
++ }
++
++ // ANNOTATED CONSTRUCTORS
++
++ @ScalarTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ public UnitTest(Iterator it) { } // scalar types
++
++ @ScalarTypesWithDefault ( )
++ public UnitTest(Set s) { } // scalarTypesAcceptDefault
++
++ @ScalarTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE
++ )
++ public UnitTest(Map s) { } // scalarTypesOverrideDefault
++
++ @ArrayTypes (
++ b = { },
++ s = { },
++ i = { },
++ l = { },
++ c = { },
++ f = { },
++ d = { },
++ bool = { },
++ str = { },
++ cls = { },
++ e = { },
++ a = { }
++ )
++ public UnitTest(List l){ } // emptyArrayTypes
++
++ @ArrayTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ public UnitTest(Collection c) { } // singleElementArrayTypes
++
++ @ArrayTypes (
++ b = { 1, 2 },
++ s = { 2, 3 },
++ i = { 3, 4 },
++ l = { 4L, 5L },
++ c = { '5', '6' },
++ f = { 6.0f, 7.0f },
++ d = { 7.0, 8.0 },
++ bool = { true, false },
++ str = { "custom", "paint" },
++ cls = { Map.class, Set.class },
++ e = { Stooge.MOE, Stooge.CURLY },
++ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
++ )
++ public UnitTest(SortedSet ss) { } // twoElementArrayTypes
++
++ @ArrayTypesWithDefault ( )
++ public UnitTest(SortedMap sm) { } // arrayTypesAcceptDefault
++
++ @ArrayTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = { @Point(x = 1, y = 2) }
++ )
++ public UnitTest(RandomAccess r) { } // arrayTypesOverrideDefault
++
++ // Marker
++ @Marker public UnitTest() { } // marker
++
++ // Single-member (shorthand)
++ @SingleMemberByte(1) public UnitTest(byte b) { }
++ @SingleMemberShort(2) public UnitTest(short s) { }
++ @SingleMemberInt(3) public UnitTest(int i) { }
++ @SingleMemberLong(4L) public UnitTest(long l) { }
++ @SingleMemberChar('5') public UnitTest(char c) { }
++ @SingleMemberFloat(6.0f) public UnitTest(float f) { }
++ @SingleMemberDouble(7.0) public UnitTest(double d) { }
++ @SingleMemberBoolean(true) public UnitTest(boolean b) { }
++ @SingleMemberString("custom") public UnitTest(String s) { }
++ @SingleMemberClass(Map.class) public UnitTest(Class c) { }
++ @SingleMemberEnum(Stooge.MOE) public UnitTest(Enum e) { }
++
++ // Single-member with default (Override)
++ @SingleMemberByteWithDef(1) public UnitTest(byte b, Set s) { }
++ @SingleMemberShortWithDef(2) public UnitTest(short s, Set x) { }
++ @SingleMemberIntWithDef(3) public UnitTest(int i, Set s) { }
++ @SingleMemberLongWithDef(4L) public UnitTest(long l, Set s) { }
++ @SingleMemberCharWithDef('5') public UnitTest(char c, Set s) { }
++ @SingleMemberFloatWithDef(6.0f) public UnitTest(float f, Set s) { }
++ @SingleMemberDoubleWithDef(7.0) public UnitTest(double d, Set s) { }
++ @SingleMemberBooleanWithDef(true) public UnitTest(boolean b, Set s) { }
++ @SingleMemberStringWithDef("custom") public UnitTest(String s, Set x) { }
++ @SingleMemberClassWithDef(Map.class) public UnitTest(Class c, Set s) { }
++ @SingleMemberEnumWithDef(Stooge.MOE) public UnitTest(Enum e, Set s) { }
++
++ // Single-member with default (Accept)
++ @SingleMemberByteWithDef public UnitTest(byte b, Map m) { }
++ @SingleMemberShortWithDef public UnitTest(short s, Map m) { }
++ @SingleMemberIntWithDef public UnitTest(int i, Map m) { }
++ @SingleMemberLongWithDef public UnitTest(long l, Map m) { }
++ @SingleMemberCharWithDef public UnitTest(char c, Map m) { }
++ @SingleMemberFloatWithDef public UnitTest(float f, Map m) { }
++ @SingleMemberDoubleWithDef public UnitTest(double d, Map m) { }
++ @SingleMemberBooleanWithDef public UnitTest(boolean b, Map m) { }
++ @SingleMemberStringWithDef public UnitTest(String s, Map m) { }
++ @SingleMemberClassWithDef public UnitTest(Class c, Map m) { }
++ @SingleMemberEnumWithDef public UnitTest(Enum e, Map m) { }
++
++ // Single member array (empty array)
++ @SingleMemberByteArray({}) public UnitTest(byte[] b) { }
++ @SingleMemberShortArray({}) public UnitTest(short[] s) { }
++ @SingleMemberIntArray({}) public UnitTest(int[] i) { }
++ @SingleMemberLongArray({}) public UnitTest(long[] l) { }
++ @SingleMemberCharArray({}) public UnitTest(char[] c) { }
++ @SingleMemberFloatArray({}) public UnitTest(float[] f) { }
++ @SingleMemberDoubleArray({}) public UnitTest(double[] d) { }
++ @SingleMemberBooleanArray({})public UnitTest(boolean[] b) { }
++ @SingleMemberStringArray({}) public UnitTest(String[] s) { }
++ @SingleMemberClassArray({}) public UnitTest(Class[] c) { }
++ @SingleMemberEnumArray({}) public UnitTest(Enum[] e) { }
++
++ // Single member array (one-element shorthand)
++ @SingleMemberByteArray(1) public UnitTest(byte[] b, Set s) { }
++ @SingleMemberShortArray(2) public UnitTest(short[] s, Set x) { }
++ @SingleMemberIntArray(3) public UnitTest(int[] i, Set s) { }
++ @SingleMemberLongArray(4L) public UnitTest(long[] l, Set s) { }
++ @SingleMemberCharArray('5') public UnitTest(char[] c, Set s) { }
++ @SingleMemberFloatArray(6.0f) public UnitTest(float[] f, Set s) { }
++ @SingleMemberDoubleArray(7.0) public UnitTest(double[] d, Set s) { }
++ @SingleMemberBooleanArray(true) public UnitTest(boolean[] b, Set s) { }
++ @SingleMemberStringArray("custom") public UnitTest(String[] s, Set x) { }
++ @SingleMemberClassArray(Map.class) public UnitTest(Class[] c, Set s) { }
++ @SingleMemberEnumArray(Stooge.MOE) public UnitTest(Enum[] e, Set s) { }
++
++ // Single member array (two elements)
++ @SingleMemberByteArray({1, 2}) public UnitTest(byte[] b, Map m) { }
++ @SingleMemberShortArray({2, 3}) public UnitTest(short[] s, Map m) { }
++ @SingleMemberIntArray({3, 4}) public UnitTest(int[] i, Map m) { }
++ @SingleMemberLongArray({4L, 5L}) public UnitTest(long[] l, Map m) { }
++ @SingleMemberCharArray({'5', '6'}) public UnitTest(char[] c, Map m) { }
++ @SingleMemberFloatArray({6.0f, 7.0f}) public UnitTest(float[] f, Map m) { }
++ @SingleMemberDoubleArray({7.0, 8.0}) public UnitTest(double[] d, Map m) { }
++ @SingleMemberBooleanArray({true, false}) public UnitTest(boolean[] b, Map m) { }
++ @SingleMemberStringArray({"custom", "paint"}) public UnitTest(String[] s, Map m) { }
++ @SingleMemberClassArray({Map.class,Set.class}) public UnitTest(Class[] c, Map m) { }
++ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) public UnitTest(Enum[] e, Map m) { }
++
++
++ // Single member array with default (override)
++ @SingleMemberByteArrayDef(1) public UnitTest(byte[] b, List l) { }
++ @SingleMemberShortArrayDef(2) public UnitTest(short[] s, List l) { }
++ @SingleMemberIntArrayDef(3) public UnitTest(int[] i, List l) { }
++ @SingleMemberLongArrayDef(4L) public UnitTest(long[] l, List x) { }
++ @SingleMemberCharArrayDef('5') public UnitTest(char[] c, List l) { }
++ @SingleMemberFloatArrayDef(6.0f) public UnitTest(float[] f, List l) { }
++ @SingleMemberDoubleArrayDef(7.0) public UnitTest(double[] d, List l) { }
++ @SingleMemberBooleanArrayDef(true) public UnitTest(boolean[] b, List l) { }
++ @SingleMemberStringArrayDef("custom") public UnitTest(String[] s, List l) { }
++ @SingleMemberClassArrayDef(Map.class) public UnitTest(Class[] c, List l) { }
++ @SingleMemberEnumArrayDef(Stooge.MOE) public UnitTest(Enum[] e, List l) { }
++
++ // Single member array with default - accept
++ @SingleMemberByteArrayDef public UnitTest(byte[] b, Collection c) { }
++ @SingleMemberShortArrayDef public UnitTest(short[] s, Collection c) { }
++ @SingleMemberIntArrayDef public UnitTest(int[] i, Collection c) { }
++ @SingleMemberLongArrayDef public UnitTest(long[] l, Collection c) { }
++ @SingleMemberCharArrayDef public UnitTest(char[] c, Collection x) { }
++ @SingleMemberFloatArrayDef public UnitTest(float[] f, Collection c) { }
++ @SingleMemberDoubleArrayDef public UnitTest(double[] d, Collection c) { }
++ @SingleMemberBooleanArrayDef public UnitTest(boolean[] b, Collection c) { }
++ @SingleMemberStringArrayDef public UnitTest(String[] s, Collection c) { }
++ @SingleMemberClassArrayDef public UnitTest(Class[] c, Collection x) { }
++ @SingleMemberEnumArrayDef public UnitTest(Enum[] e, Collection c) { }
++
++ // ANNOTATED PARAMETERS
++
++ public void scalarTypesParam(
++ @ScalarTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ int x) { }
++
++
++ public void scalarTypesAcceptDefaultParam(
++ @ScalarTypesWithDefault int x) { }
++
++ public void scalarTypesOverrideDefaultParam(
++ @ScalarTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE
++ )
++ int x) { }
++
++ public void emptyArrayTypesParam(
++ @ArrayTypes (
++ b = { },
++ s = { },
++ i = { },
++ l = { },
++ c = { },
++ f = { },
++ d = { },
++ bool = { },
++ str = { },
++ cls = { },
++ e = { },
++ a = { }
++ )
++ int x) { }
++
++ public void singleElementArrayTypesParam(
++ @ArrayTypes (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = @Point(x = 1, y = 2)
++ )
++ int x) { }
++
++ public void twoElementArrayTypesParam(
++ @ArrayTypes (
++ b = { 1, 2 },
++ s = { 2, 3 },
++ i = { 3, 4 },
++ l = { 4L, 5L },
++ c = { '5', '6' },
++ f = { 6.0f, 7.0f },
++ d = { 7.0, 8.0 },
++ bool = { true, false },
++ str = { "custom", "paint" },
++ cls = { Map.class, Set.class },
++ e = { Stooge.MOE, Stooge.CURLY },
++ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) }
++ )
++ int x) { }
++
++ public void arrayTypesAcceptDefaultParam(
++ @ArrayTypesWithDefault
++ int x) { }
++
++ public void arrayTypesOverrideDefaultParam(
++ @ArrayTypesWithDefault (
++ b = 1,
++ s = 2,
++ i = 3,
++ l = 4L,
++ c = '5',
++ f = 6.0f,
++ d = 7.0,
++ bool = true,
++ str = "custom",
++ cls = Map.class,
++ e = Stooge.MOE,
++ a = { @Point(x = 1, y = 2) }
++ )
++ int x) { }
++
++ // Marker
++ public void markerParam(@Marker int x) { }
++
++ // Single-member (shorthand)
++ public void SingleMemberByteParam(@SingleMemberByte(1) int x) {}
++ public void SingleMemberShortParam(@SingleMemberShort(2) int x) {}
++ public void SingleMemberIntParam(@SingleMemberInt(3) int x) {}
++ public void SingleMemberLongParam(@SingleMemberLong(4L) int x) {}
++ public void SingleMemberCharParam(@SingleMemberChar('5') int x) {}
++ public void SingleMemberFloatParam(@SingleMemberFloat(6.0f) int x) {}
++ public void SingleMemberDoubleParam(@SingleMemberDouble(7.0) int x) {}
++ public void SingleMemberBooleanParam(@SingleMemberBoolean(true) int x) {}
++ public void SingleMemberStringParam(@SingleMemberString("custom") int x) {}
++ public void SingleMemberClassParam(@SingleMemberClass(Map.class) int x) {}
++ public void SingleMemberEnumParam(@SingleMemberEnum(Stooge.MOE) int x) {}
++
++ // Single-member with default (Override)
++ public void SingleMemberByteOvrdDefParam(@SingleMemberByteWithDef(1) int x) {}
++ public void SingleMemberShortOvrdDefParam(@SingleMemberShortWithDef(2) int x) {}
++ public void SingleMemberIntOvrdDefParam(@SingleMemberIntWithDef(3) int x) {}
++ public void SingleMemberLongOvrdDefParam(@SingleMemberLongWithDef(4L) int x) {}
++ public void SingleMemberCharOvrdDefParam(@SingleMemberCharWithDef('5') int x) {}
++ public void SingleMemberFloatOvrdDefParam(@SingleMemberFloatWithDef(6.0f) int x) {}
++ public void SingleMemberDoubleOvrdDefParam(@SingleMemberDoubleWithDef(7.0) int x) {}
++ public void SingleMemberBooleanOvrdDefParam(@SingleMemberBooleanWithDef(true) int x) {}
++ public void SingleMemberStringOvrdDefParam(@SingleMemberStringWithDef("custom") int x) {}
++ public void SingleMemberClassOvrdDefParam(@SingleMemberClassWithDef(Map.class) int x) {}
++ public void SingleMemberEnumOvrdDefParam(@SingleMemberEnumWithDef(Stooge.MOE) int x) {}
++
++ // Single-member with default (Accept)
++ public void SingleMemberByteAcceptDefParam(@SingleMemberByteWithDef int x) {}
++ public void SingleMemberShortAcceptDefParam(@SingleMemberShortWithDef int x) {}
++ public void SingleMemberIntAcceptDefParam(@SingleMemberIntWithDef int x) {}
++ public void SingleMemberLongAcceptDefParam(@SingleMemberLongWithDef int x) {}
++ public void SingleMemberCharAcceptDefParam(@SingleMemberCharWithDef int x) {}
++ public void SingleMemberFloatAcceptDefParam(@SingleMemberFloatWithDef int x) {}
++ public void SingleMemberDoubleAcceptDefParam(@SingleMemberDoubleWithDef int x) {}
++ public void SingleMemberBooleanAcceptDefParam(@SingleMemberBooleanWithDef int x){}
++ public void SingleMemberStringAcceptDefParam(@SingleMemberStringWithDef int x) {}
++ public void SingleMemberClassAcceptDefParam(@SingleMemberClassWithDef int x) {}
++ public void SingleMemberEnumAcceptDefParam(@SingleMemberEnumWithDef int x) {}
++
++ // Single member array (empty array)
++ public void SingleMemberByteArrEmptyParam(@SingleMemberByteArray({}) int x) {}
++ public void SingleMemberShortArrEmptyParam(@SingleMemberShortArray({}) int x) {}
++ public void SingleMemberIntArrEmptyParam(@SingleMemberIntArray({}) int x) {}
++ public void SingleMemberLongArrEmptyParam(@SingleMemberLongArray({}) int x) {}
++ public void SingleMemberCharArrEmptyParam(@SingleMemberCharArray({}) int x) {}
++ public void SingleMemberFloatArrEmptyParam(@SingleMemberFloatArray({}) int x) {}
++ public void SingleMemberDoubleArrEmptyParam(@SingleMemberDoubleArray({}) int x) {}
++ public void SingleMemberBooleanArrEmptyParam(@SingleMemberBooleanArray({}) int x) {}
++ public void SingleMemberStringArrEmptyParam(@SingleMemberStringArray({}) int x) {}
++ public void SingleMemberClassArrEmptyParam(@SingleMemberClassArray({}) int x) {}
++ public void SingleMemberEnumArrEmptyParam(@SingleMemberEnumArray({}) int x) {}
++
++ // Single member array (one-element shorthand)
++ public void SingleMemberByteArrOneParam(@SingleMemberByteArray(1) int x) {}
++ public void SingleMemberShortArrOneParam(@SingleMemberShortArray(2) int x) {}
++ public void SingleMemberIntArrOneParam(@SingleMemberIntArray(3) int x) {}
++ public void SingleMemberLongArrOneParam(@SingleMemberLongArray(4L) int x) {}
++ public void SingleMemberCharArrOneParam(@SingleMemberCharArray('5') int x) {}
++ public void SingleMemberFloatArrOneParam(@SingleMemberFloatArray(6.0f) int x) {}
++ public void SingleMemberDoubleArrOneParam(@SingleMemberDoubleArray(7.0) int x) {}
++ public void SingleMemberBooleanArrOneParam(@SingleMemberBooleanArray(true) int x) {}
++ public void SingleMemberStringArrOneParam(@SingleMemberStringArray("custom") int x) {}
++ public void SingleMemberClassArrOneParam(@SingleMemberClassArray(Map.class) int x) {}
++ public void SingleMemberEnumArrOneParam(@SingleMemberEnumArray(Stooge.MOE) int x) {}
++
++ // Single member array (two elements)
++ public void SingleMemberByteArrTwoParam(@SingleMemberByteArray({1, 2}) int x) {}
++ public void SingleMemberShortArrTwoParam(@SingleMemberShortArray({2, 3}) int x) {}
++ public void SingleMemberIntArrTwoParam(@SingleMemberIntArray({3, 4}) int x) {}
++ public void SingleMemberLongArrTwoParam(@SingleMemberLongArray({4L, 5L}) int x) {}
++ public void SingleMemberCharArrTwoParam(@SingleMemberCharArray({'5', '6'}) int x) {}
++ public void SingleMemberFloatArrTwoParam(@SingleMemberFloatArray({6.0f, 7.0f}) int x) {}
++ public void SingleMemberDoubleArrTwoParam(@SingleMemberDoubleArray({7.0, 8.0}) int x) {}
++ public void SingleMemberBooleanArrTwoParam(@SingleMemberBooleanArray({true, false}) int x){}
++ public void SingleMemberStringArrTwoParam(@SingleMemberStringArray({"custom", "paint"}) int x) {}
++ public void SingleMemberClassArrTwoParam(@SingleMemberClassArray({Map.class, Set.class}) int x) {}
++ public void SingleMemberEnumArrTwoParam(@SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) int x) {}
++
++ // Single member array with default (override)
++ public void SingleMemberByteArrOvrdDefParam(@SingleMemberByteArrayDef(1) int x) {}
++ public void SingleMemberShortArrOvrdDefParam(@SingleMemberShortArrayDef(2) int x) {}
++ public void SingleMemberIntArrOvrdDefParam(@SingleMemberIntArrayDef(3) int x) {}
++ public void SingleMemberLongArrOvrdDefParam(@SingleMemberLongArrayDef(4L) int x) {}
++ public void SingleMemberCharArrOvrdDefParam(@SingleMemberCharArrayDef('5') int x) {}
++ public void SingleMemberFloatArrOvrdDefParam(@SingleMemberFloatArrayDef(6.0f) int x) {}
++ public void SingleMemberDoubleArrOvrdDefParam(@SingleMemberDoubleArrayDef(7.0) int x) {}
++ public void SingleMemberBooleanArrOvrdDefParam(@SingleMemberBooleanArrayDef(true) int x){}
++ public void SingleMemberStringArrOvrdDefParam(@SingleMemberStringArrayDef("custom") int x) {}
++ public void SingleMemberClassArrOvrdDefParam(@SingleMemberClassArrayDef(Map.class) int x) {}
++ public void SingleMemberEnumArrOvrdDefParam(@SingleMemberEnumArrayDef(Stooge.MOE) int x) {}
++
++ // Single member array with default - accept
++ public void SingleMemberByteArrAcceptDefParam(@SingleMemberByteArrayDef int x) {}
++ public void SingleMemberShortArrAcceptDefParam(@SingleMemberShortArrayDef int x) {}
++ public void SingleMemberIntArrAcceptDefParam(@SingleMemberIntArrayDef int x) {}
++ public void SingleMemberLongArrAcceptDefParam(@SingleMemberLongArrayDef int x) {}
++ public void SingleMemberCharArrAcceptDefParam(@SingleMemberCharArrayDef int x) {}
++ public void SingleMemberFloatArrAcceptDefParam(@SingleMemberFloatArrayDef int x) {}
++ public void SingleMemberDoubleArrAcceptDefParam(@SingleMemberDoubleArrayDef int x) {}
++ public void SingleMemberBooleanArrAcceptDefParam(@SingleMemberBooleanArrayDef int x){}
++ public void SingleMemberStringArrAcceptDefParam(@SingleMemberStringArrayDef int x) {}
++ public void SingleMemberClassArrAcceptDefParam(@SingleMemberClassArrayDef int x) {}
++ public void SingleMemberEnumArrAcceptDefParam(@SingleMemberEnumArrayDef int x) {}
++}
++
++// Helper types
++
++enum Stooge { LARRY, MOE, CURLY }
++
++ at Target({}) @interface Point { int x(); int y(); }
++
++// ANNOTATION TYPES
++
++ at 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();
++}
++
++ at 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);
++}
++
++ at 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();
++}
++
++ at 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) };
++}
++
++ at Retention(RUNTIME) @interface Marker { }
++
++ at Retention(RUNTIME) @interface SingleMemberByte { byte value(); }
++ at Retention(RUNTIME) @interface SingleMemberShort { short value(); }
++ at Retention(RUNTIME) @interface SingleMemberInt { int value(); }
++ at Retention(RUNTIME) @interface SingleMemberLong { long value(); }
++ at Retention(RUNTIME) @interface SingleMemberChar { char value(); }
++ at Retention(RUNTIME) @interface SingleMemberFloat { float value(); }
++ at Retention(RUNTIME) @interface SingleMemberDouble { double value(); }
++ at Retention(RUNTIME) @interface SingleMemberBoolean { boolean value(); }
++ at Retention(RUNTIME) @interface SingleMemberString { String value(); }
++ at Retention(RUNTIME) @interface SingleMemberClass { Class value(); }
++ at Retention(RUNTIME) @interface SingleMemberEnum { Stooge value(); }
++
++ at Retention(RUNTIME) @interface SingleMemberByteWithDef { byte value() default 11; }
++ at Retention(RUNTIME) @interface SingleMemberShortWithDef { short value() default 12; }
++ at Retention(RUNTIME) @interface SingleMemberIntWithDef { int value() default 13; }
++ at Retention(RUNTIME) @interface SingleMemberLongWithDef { long value() default 14; }
++ at Retention(RUNTIME) @interface SingleMemberCharWithDef { char value() default 'V'; }
++ at Retention(RUNTIME) @interface SingleMemberFloatWithDef { float value() default 16.0f; }
++ at Retention(RUNTIME) @interface SingleMemberDoubleWithDef { double value() default 17.0; }
++ at Retention(RUNTIME) @interface SingleMemberBooleanWithDef { boolean value() default false; }
++ at Retention(RUNTIME) @interface SingleMemberStringWithDef { String value() default "default"; }
++ at Retention(RUNTIME) @interface SingleMemberClassWithDef { Class value() default Class.class; }
++ at Retention(RUNTIME) @interface SingleMemberEnumWithDef { Stooge value() default Stooge.LARRY; }
++
++ at Retention(RUNTIME) @interface SingleMemberByteArray { byte[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberShortArray { short[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberIntArray { int[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberLongArray { long[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberCharArray { char[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberFloatArray { float[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberDoubleArray { double[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberBooleanArray { boolean[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberStringArray { String[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberClassArray { Class[] value(); }
++ at Retention(RUNTIME) @interface SingleMemberEnumArray { Stooge[] value(); }
++
++ at Retention(RUNTIME) @interface SingleMemberByteArrayDef { byte[] value() default { 11 }; }
++ at Retention(RUNTIME) @interface SingleMemberShortArrayDef { short[] value() default { 12 }; }
++ at Retention(RUNTIME) @interface SingleMemberIntArrayDef { int[] value() default { 13 }; }
++ at Retention(RUNTIME) @interface SingleMemberLongArrayDef { long[] value() default { 14 }; }
++ at Retention(RUNTIME) @interface SingleMemberCharArrayDef { char[] value() default { 'V' }; }
++ at Retention(RUNTIME) @interface SingleMemberFloatArrayDef { float[] value() default { 16.0f };}
++ at Retention(RUNTIME) @interface SingleMemberDoubleArrayDef { double[] value() default { 17.0 }; }
++ at Retention(RUNTIME) @interface SingleMemberBooleanArrayDef { boolean[] value() default { false };}
++ at Retention(RUNTIME) @interface SingleMemberStringArrayDef {
++ String[] value() default {"default"};
++}
++ at Retention(RUNTIME) @interface SingleMemberClassArrayDef {
++ Class[] value() default {Class.class};
++}
++ at Retention(RUNTIME) @interface SingleMemberEnumArrayDef {
++ Stooge[] value() default {Stooge.LARRY};
++}
++
++// Annotation types for inheritance and declared-annotations tests
++ at 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 { }
diff -r 3b8dcbd3d44d patches/openjdk/bidi-tests.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/bidi-tests.patch Wed Feb 11 02:15:37 2009 +0000
@@ -0,0 +1,295 @@
+
+# HG changeset patch
+# User peytoia
+# Date 1224218043 -32400
+# Node ID 8ea49fa4c2f761eeb67711ba2fa5482cb3b0347c
+# Parent 244f62312fec34c292e082ba3bb9c76aef30858e
+6759521: Move Bidi test programs from closed to open.
+Reviewed-by: okutsu
+
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ openjdk/jdk/test/java/text/Bidi/BidiBug.java Fri Oct 17 13:34:03 2008 +0900
+@@ -0,0 +1,41 @@
++/*
++ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 4827312
++ * @summary verify that argument validity check is not fooled by overflow
++ */
++public class BidiBug {
++ public static void main(String[] args) {
++ try {
++ byte buff[] = new byte[3000];
++ java.text.Bidi bidi = new java.text.Bidi(new char[20],10,buff,Integer.MAX_VALUE-3,4,1);
++ }
++ catch (IllegalArgumentException e) {
++ System.out.println(e);
++ return; // success
++ }
++ throw new RuntimeException("didn't throw error, though we didn't crash either");
++ }
++}
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ openjdk/jdk/test/java/text/Bidi/BidiEmbeddingTest.java Fri Oct 17 13:34:03 2008 +0900
+@@ -0,0 +1,132 @@
++/*
++ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 4396492 4396496 4778510
++ * @summary verify that the embedding values processed by the bidi code use negative values to
++ * indicate overrides, rather than using bit 7. Also tests Bidi without loading awt classes to
++ * confirm that Bidi can be used without awt. Verify that embedding level 0 is properly mapped
++ * to the base embedding level.
++ */
++
++import java.awt.Color;
++import java.awt.Frame;
++import java.awt.font.TextAttribute;
++import java.text.AttributedString;
++import java.text.Bidi;
++
++public class BidiEmbeddingTest {
++ public static void main(String[] args) {
++ // to regress embedding test against old fix, call with an arg. A window will pop
++ // up causing awt lib to be loaded so the vm won't die with the unsatisfied link error.
++ if (args.length > 0) {
++ Frame f = new Frame();
++ f.setSize(300, 300);
++ f.setBackground(Color.white);
++ f.show();
++ }
++
++ test1();
++ test2();
++ }
++
++ static void test1() {
++ String target = "BACK WARDS";
++ String str = "If this text is >" + target + "< the test passed.";
++ int start = str.indexOf(target);
++ int limit = start + target.length();
++
++ System.out.println("start: " + start + " limit: " + limit);
++
++ AttributedString astr = new AttributedString(str);
++ astr.addAttribute(TextAttribute.BIDI_EMBEDDING,
++ new Integer(-1),
++ start,
++ limit);
++
++ Bidi bidi = new Bidi(astr.getIterator());
++
++ for (int i = 0; i < bidi.getRunCount(); ++i) {
++ System.out.println("run " + i +
++ " from " + bidi.getRunStart(i) +
++ " to " + bidi.getRunLimit(i) +
++ " at level " + bidi.getRunLevel(i));
++ }
++
++ System.out.println(bidi);
++
++ byte[] embs = new byte[str.length() + 3];
++ for (int i = start + 1; i < limit + 1; ++i) {
++ embs[i] = -1;
++ }
++
++ Bidi bidi2 = new Bidi(str.toCharArray(), 0, embs, 1, str.length(), Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
++ for (int i = 0; i < bidi2.getRunCount(); ++i) {
++ System.out.println("run " + i +
++ " from " + bidi2.getRunStart(i) +
++ " to " + bidi2.getRunLimit(i) +
++ " at level " + bidi2.getRunLevel(i));
++ }
++
++ System.out.println(bidi2);
++
++ if (bidi.getRunCount() != 3 || bidi2.getRunCount() != 3) {
++ throw new Error("Bidi run count incorrect");
++ }
++ }
++
++ // make sure BIDI_EMBEDDING values of 0 are mapped to base run direction, instead of flagging an error.
++ static void test2() {
++ String target = "BACK WARDS";
++ String str = "If this text is >" + target + "< the test passed.";
++ int length = str.length();
++ int start = str.indexOf(target);
++ int limit = start + target.length();
++
++ System.out.println("start: " + start + " limit: " + limit);
++
++ AttributedString astr = new AttributedString(str);
++ astr.addAttribute(TextAttribute.RUN_DIRECTION, TextAttribute.RUN_DIRECTION_RTL);
++
++ astr.addAttribute(TextAttribute.BIDI_EMBEDDING,
++ new Integer(-3),
++ start,
++ limit);
++
++ Bidi bidi = new Bidi(astr.getIterator());
++
++ for (int i = 0; i < bidi.getRunCount(); ++i) {
++ System.out.println("run " + i +
++ " from " + bidi.getRunStart(i) +
++ " to " + bidi.getRunLimit(i) +
++ " at level " + bidi.getRunLevel(i));
++ }
++
++ System.out.println(bidi);
++
++ if (bidi.getRunCount() != 6) { // runs of spaces and angles at embedding bound,s and final period, each get level 1
++ throw new Error("Bidi embedding processing failed");
++ }
++ }
++}
+--- /dev/null Thu Jan 01 00:00:00 1970 +0000
++++ openjdk/jdk/test/java/text/Bidi/BidiSurrogateTest.java Fri Oct 17 13:34:03 2008 +0900
+@@ -0,0 +1,103 @@
++/*
++ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
++ *
++ * This code is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 only, as
++ * published by the Free Software Foundation.
++ *
++ * This code is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * version 2 for more details (a copy is included in the LICENSE file that
++ * accompanied this code).
++ *
++ * You should have received a copy of the GNU General Public License version
++ * 2 along with this work; if not, write to the Free Software Foundation,
++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
++ *
++ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 4888843
++ * @summary verify that surrogate pairs representing codepoints with R or AL directionality
++ * and correctly recognized and reordered.
++ */
++
++import java.text.Bidi;
++
++public class BidiSurrogateTest {
++ private static final String RTLS = new String(Character.toChars(0x10800)); // surrogate code point with R directionality
++ private static final String LTRS = new String(Character.toChars(0x107ff)); // surrogate code point with L directionality
++ private static final String LRE = "\u202a";
++ private static final String RLE = "\u202b";
++ private static final String PDF = "\u202c";
++
++
++ public static void main(String[] args) {
++ new BidiSurrogateTest().test();
++ }
++
++ void test() {
++ test0();
++ test1();
++ }
++
++ void test0() {
++ // test unpaired surrogates - should have L directionality
++ testRequiresBidi("\ud800", false); // unpaired lead surrogate
++ testRequiresBidi("\udc00", false); // unpaired trail surrogate
++ testRequiresBidi("\udc00\ud800", false); // out of order surrogates
++ testRequiresBidi("a\udc00b\ud800c", false); // out of order surrogates split
++ testRequiresBidi(LTRS, false); // supplementary with L
++ testRequiresBidi(RTLS, true); // supplementary with R
++ testRequiresBidi("a" + RTLS + "b", true); // R supplementary in LTR text
++ testRequiresBidi(LTRS + RTLS, true); // R supplementary in LTR supplementary text
++ testRequiresBidi(LRE, false); // LRE lone embedding
++ testRequiresBidi(RLE, true); // RLE lone embedding
++ testRequiresBidi(PDF, false); // PDF lone pop embedding
++ }
++
++ void testRequiresBidi(String string, boolean requiresBidi) {
++ char[] text = string.toCharArray();
++ if (Bidi.requiresBidi(text, 0, text.length) != requiresBidi) {
++ throw new RuntimeException("testRequiresBidi failed with '" + string + "', " + requiresBidi);
++ }
++ }
++
++ void test1() {
++ // test that strings with surrogate runs process surrogate directionality ok
++ testBidi("This is a string with " + LTRS + " in it.", false);
++ testBidi("This is a string with \ud800 in it.", false);
++ testBidi("This is a string with \u0640 in it.", 22, 1);
++ testBidi(RTLS, true);
++ testBidi("This is a string with " + RTLS + RTLS + RTLS + " in it.", 22, 6);
++ }
++
++ void testBidi(String string, boolean directionIsRTL) {
++ Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
++ if (bidi.isMixed()) {
++ throw new RuntimeException("bidi is mixed");
++ }
++ if (bidi.isRightToLeft() != directionIsRTL) {
++ throw new RuntimeException("bidi is not " + (directionIsRTL ? "rtl" : "ltr"));
++ }
++ }
++
++ void testBidi(String string, int rtlstart, int rtllength) {
++ Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
++ for (int i = 0; i < bidi.getRunCount(); ++i) {
++ if ((bidi.getRunLevel(i) & 1) != 0) {
++ if (bidi.getRunStart(i) != rtlstart ||
++ bidi.getRunLimit(i) != rtlstart + rtllength) {
++ throw new RuntimeException("first rtl run didn't match " + rtlstart + ", " + rtllength);
++ }
++ break;
++ }
++ }
++ }
++}
+
More information about the distro-pkg-dev
mailing list