Mercurial > hg > release > icedtea-1.9
changeset 1632:5d4d8012aa03
Backport newly Freed tests.
2009-02-11 Andrew John Hughes <ahughes@redhat.com>
* Makefile.am:
Add new patches.
* patches/openjdk/bidi-tests.patch,
* patches/openjdk/annotation-tests.patch:
New.
| author | Andrew John Hughes <ahughes@redhat.com> |
|---|---|
| date | Wed, 11 Feb 2009 02:18:27 +0000 |
| parents | 3b8dcbd3d44d |
| children | 24c29e381e49 |
| files | ChangeLog Makefile.am patches/openjdk/annotation-tests.patch patches/openjdk/bidi-tests.patch |
| diffstat | 4 files changed, 6174 insertions(+), 1 deletions(-) [+] |
line wrap: on
line diff
--- a/ChangeLog Tue Feb 10 16:19:54 2009 -0500 +++ b/ChangeLog Wed Feb 11 02:18:27 2009 +0000 @@ -1,4 +1,13 @@ +2009-02-11 Andrew John Hughes <ahughes@redhat.com> + + * Makefile.am: + Add new patches. + * patches/openjdk/bidi-tests.patch, + * patches/openjdk/annotation-tests.patch: + New. + 2009-02-10 Deepak Bhole <dbhole@redhat.com> + * plugin/icedtea/sun/applet/PluginAppletSecurityContext.java: Fix exit permissions for applets. * plugin/icedtea/sun/applet/PluginStreamHandler.java: Fix harmless, but
--- a/Makefile.am Tue Feb 10 16:19:54 2009 -0500 +++ b/Makefile.am Wed Feb 11 02:18:27 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 += \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/annotation-tests.patch Wed Feb 11 02:18:27 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 ++@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME) ++@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. ++ */ ++@Missing ++@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. ++ */ ++@MissingWrapper(@Missing) ++@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. ++ */ ++@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. ++ */ ++@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. ++ */ ++@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 ++ */ ++ ++@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.*; ++ ++@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"); ++ } ++} ++ ++@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 } ++ ++@Target({}) @interface Point { int x(); int y(); } ++ ++// ANNOTATION TYPES ++ ++@Retention(RUNTIME) @interface ScalarTypes { ++ byte b(); ++ short s(); ++ int i(); ++ long l(); ++ char c(); ++ float f(); ++ double d(); ++ boolean bool(); ++ String str(); ++ Class cls(); ++ Stooge e(); ++ Point a(); ++} ++ ++@Retention(RUNTIME) @interface ScalarTypesWithDefault { ++ byte b() default 11; ++ short s() default 12; ++ int i() default 13; ++ long l() default 14; ++ char c() default 'V'; ++ float f() default 16.0f; ++ double d() default 17.0; ++ boolean bool() default false; ++ String str() default "default"; ++ Class cls() default Class.class; ++ Stooge e() default Stooge.LARRY; ++ Point a() default @Point(x = 11, y = 12); ++} ++ ++@Retention(RUNTIME) @interface ArrayTypes { ++ byte[] b(); ++ short[] s(); ++ int[] i(); ++ long[] l(); ++ char[] c(); ++ float[] f(); ++ double[] d(); ++ boolean[] bool(); ++ String[] str(); ++ Class[] cls(); ++ Stooge[] e(); ++ Point[] a(); ++} ++ ++@Retention(RUNTIME) @interface ArrayTypesWithDefault { ++ byte[] b() default { 11 }; ++ short[] s() default { 12 }; ++ int[] i() default { 13 }; ++ long[] l() default { 14L }; ++ char[] c() default { 'V' }; ++ float[] f() default { 16.0f }; ++ double[] d() default { 17.0 }; ++ boolean[] bool() default { false }; ++ String[] str() default { "default" }; ++ Class[] cls() default { Class.class }; ++ Stooge[] e() default { Stooge.LARRY }; ++ Point[] a() default { @Point(x = 11, y = 12) }; ++} ++ ++@Retention(RUNTIME) @interface Marker { } ++ ++@Retention(RUNTIME) @interface SingleMemberByte { byte value(); } ++@Retention(RUNTIME) @interface SingleMemberShort { short value(); } ++@Retention(RUNTIME) @interface SingleMemberInt { int value(); } ++@Retention(RUNTIME) @interface SingleMemberLong { long value(); } ++@Retention(RUNTIME) @interface SingleMemberChar { char value(); } ++@Retention(RUNTIME) @interface SingleMemberFloat { float value(); } ++@Retention(RUNTIME) @interface SingleMemberDouble { double value(); } ++@Retention(RUNTIME) @interface SingleMemberBoolean { boolean value(); } ++@Retention(RUNTIME) @interface SingleMemberString { String value(); } ++@Retention(RUNTIME) @interface SingleMemberClass { Class value(); } ++@Retention(RUNTIME) @interface SingleMemberEnum { Stooge value(); } ++ ++@Retention(RUNTIME) @interface SingleMemberByteWithDef { byte value() default 11; } ++@Retention(RUNTIME) @interface SingleMemberShortWithDef { short value() default 12; } ++@Retention(RUNTIME) @interface SingleMemberIntWithDef { int value() default 13; } ++@Retention(RUNTIME) @interface SingleMemberLongWithDef { long value() default 14; } ++@Retention(RUNTIME) @interface SingleMemberCharWithDef { char value() default 'V'; } ++@Retention(RUNTIME) @interface SingleMemberFloatWithDef { float value() default 16.0f; } ++@Retention(RUNTIME) @interface SingleMemberDoubleWithDef { double value() default 17.0; } ++@Retention(RUNTIME) @interface SingleMemberBooleanWithDef { boolean value() default false; } ++@Retention(RUNTIME) @interface SingleMemberStringWithDef { String value() default "default"; } ++@Retention(RUNTIME) @interface SingleMemberClassWithDef { Class value() default Class.class; } ++@Retention(RUNTIME) @interface SingleMemberEnumWithDef { Stooge value() default Stooge.LARRY; } ++ ++@Retention(RUNTIME) @interface SingleMemberByteArray { byte[] value(); } ++@Retention(RUNTIME) @interface SingleMemberShortArray { short[] value(); } ++@Retention(RUNTIME) @interface SingleMemberIntArray { int[] value(); } ++@Retention(RUNTIME) @interface SingleMemberLongArray { long[] value(); } ++@Retention(RUNTIME) @interface SingleMemberCharArray { char[] value(); } ++@Retention(RUNTIME) @interface SingleMemberFloatArray { float[] value(); } ++@Retention(RUNTIME) @interface SingleMemberDoubleArray { double[] value(); } ++@Retention(RUNTIME) @interface SingleMemberBooleanArray { boolean[] value(); } ++@Retention(RUNTIME) @interface SingleMemberStringArray { String[] value(); } ++@Retention(RUNTIME) @interface SingleMemberClassArray { Class[] value(); } ++@Retention(RUNTIME) @interface SingleMemberEnumArray { Stooge[] value(); } ++ ++@Retention(RUNTIME) @interface SingleMemberByteArrayDef { byte[] value() default { 11 }; } ++@Retention(RUNTIME) @interface SingleMemberShortArrayDef { short[] value() default { 12 }; } ++@Retention(RUNTIME) @interface SingleMemberIntArrayDef { int[] value() default { 13 }; } ++@Retention(RUNTIME) @interface SingleMemberLongArrayDef { long[] value() default { 14 }; } ++@Retention(RUNTIME) @interface SingleMemberCharArrayDef { char[] value() default { 'V' }; } ++@Retention(RUNTIME) @interface SingleMemberFloatArrayDef { float[] value() default { 16.0f };} ++@Retention(RUNTIME) @interface SingleMemberDoubleArrayDef { double[] value() default { 17.0 }; } ++@Retention(RUNTIME) @interface SingleMemberBooleanArrayDef { boolean[] value() default { false };} ++@Retention(RUNTIME) @interface SingleMemberStringArrayDef { ++ String[] value() default {"default"}; ++} ++@Retention(RUNTIME) @interface SingleMemberClassArrayDef { ++ Class[] value() default {Class.class}; ++} ++@Retention(RUNTIME) @interface SingleMemberEnumArrayDef { ++ Stooge[] value() default {Stooge.LARRY}; ++} ++ ++// Annotation types for inheritance and declared-annotations tests ++@Inherited @Retention(RUNTIME) @interface Foo { } ++ @Retention(RUNTIME) @interface Bar { } ++ ++ ++ // ANNOTATED CLASSES ++ ++ @ScalarTypes ( ++ b = 1, ++ s = 2, ++ i = 3, ++ l = 4L, ++ c = '5', ++ f = 6.0f, ++ d = 7.0, ++ bool = true, ++ str = "custom", ++ cls = Map.class, ++ e = Stooge.MOE, ++ a = @Point(x = 1, y = 2) ++ ) ++ class scalarTypesClass { } ++ ++ @ScalarTypesWithDefault ( ) ++ class scalarTypesAcceptDefaultClass { } ++ ++ @ScalarTypesWithDefault ( ++ b = 1, ++ s = 2, ++ i = 3, ++ l = 4L, ++ c = '5', ++ f = 6.0f, ++ d = 7.0, ++ bool = true, ++ str = "custom", ++ cls = Map.class, ++ e = Stooge.MOE ++ ) ++ class scalarTypesOverrideDefaultClass { } ++ ++ @ArrayTypes ( ++ b = { }, ++ s = { }, ++ i = { }, ++ l = { }, ++ c = { }, ++ f = { }, ++ d = { }, ++ bool = { }, ++ str = { }, ++ cls = { }, ++ e = { }, ++ a = { } ++ ) ++ class emptyArrayTypesClass { } ++ ++ @ArrayTypes ( ++ b = 1, ++ s = 2, ++ i = 3, ++ l = 4L, ++ c = '5', ++ f = 6.0f, ++ d = 7.0, ++ bool = true, ++ str = "custom", ++ cls = Map.class, ++ e = Stooge.MOE, ++ a = @Point(x = 1, y = 2) ++ ) ++ class singleElementArrayTypesClass { } ++ ++ @ArrayTypes ( ++ b = { 1, 2 }, ++ s = { 2, 3 }, ++ i = { 3, 4 }, ++ l = { 4L, 5L }, ++ c = { '5', '6' }, ++ f = { 6.0f, 7.0f }, ++ d = { 7.0, 8.0 }, ++ bool = { true, false }, ++ str = { "custom", "paint" }, ++ cls = { Map.class, Set.class }, ++ e = { Stooge.MOE, Stooge.CURLY }, ++ a = { @Point(x = 1, y = 2), @Point(x = 3, y = 4) } ++ ) ++ class twoElementArrayTypesClass { } ++ ++ @ArrayTypesWithDefault ( ++ ) ++ class arrayTypesAcceptDefaultClass { } ++ ++ @ArrayTypesWithDefault ( ++ b = 1, ++ s = 2, ++ i = 3, ++ l = 4L, ++ c = '5', ++ f = 6.0f, ++ d = 7.0, ++ bool = true, ++ str = "custom", ++ cls = Map.class, ++ e = Stooge.MOE, ++ a = { @Point(x = 1, y = 2) } ++ ) ++ class arrayTypesOverrideDefaultClass { } ++ ++ @Marker class markerClass { } ++ ++ // Single-member (shorthand) ++ @SingleMemberByte(1) class SingleMemberByteClass { } ++ @SingleMemberShort(2) class SingleMemberShortClass { } ++ @SingleMemberInt(3) class SingleMemberIntClass { } ++ @SingleMemberLong(4L) class SingleMemberLongClass { } ++ @SingleMemberChar('5') class SingleMemberCharClass { } ++ @SingleMemberFloat(6.0f) class SingleMemberFloatClass { } ++ @SingleMemberDouble(7.0) class SingleMemberDoubleClass { } ++ @SingleMemberBoolean(true) class SingleMemberBooleanClass { } ++ @SingleMemberString("custom") class SingleMemberStringClass { } ++ @SingleMemberClass(Map.class) class SingleMemberClassClass { } ++ @SingleMemberEnum(Stooge.MOE) class SingleMemberEnumClass { } ++ ++ // Single-member with default (Override) ++ @SingleMemberByteWithDef(1) class SingleMemberByteOvrdDefClass { } ++ @SingleMemberShortWithDef(2) class SingleMemberShortOvrdDefClass { } ++ @SingleMemberIntWithDef(3) class SingleMemberIntOvrdDefClass { } ++ @SingleMemberLongWithDef(4L) class SingleMemberLongOvrdDefClass { } ++ @SingleMemberCharWithDef('5') class SingleMemberCharOvrdDefClass { } ++ @SingleMemberFloatWithDef(6.0f) class SingleMemberFloatOvrdDefClass { } ++ @SingleMemberDoubleWithDef(7.0) class SingleMemberDoubleOvrdDefClass { } ++ @SingleMemberBooleanWithDef(true) class SingleMemberBooleanOvrdDefClass { } ++ @SingleMemberStringWithDef("custom") class SingleMemberStringOvrdDefClass { } ++ @SingleMemberClassWithDef(Map.class) class SingleMemberClassOvrdDefClass { } ++ @SingleMemberEnumWithDef(Stooge.MOE) class SingleMemberEnumOvrdDefClass { } ++ ++ // Single-member with default (Accept) ++ @SingleMemberByteWithDef class SingleMemberByteAcceptDefClass { } ++ @SingleMemberShortWithDef class SingleMemberShortAcceptDefClass { } ++ @SingleMemberIntWithDef class SingleMemberIntAcceptDefClass { } ++ @SingleMemberLongWithDef class SingleMemberLongAcceptDefClass { } ++ @SingleMemberCharWithDef class SingleMemberCharAcceptDefClass { } ++ @SingleMemberFloatWithDef class SingleMemberFloatAcceptDefClass { } ++ @SingleMemberDoubleWithDef class SingleMemberDoubleAcceptDefClass { } ++ @SingleMemberBooleanWithDef class SingleMemberBooleanAcceptDefClass { } ++ @SingleMemberStringWithDef class SingleMemberStringAcceptDefClass { } ++ @SingleMemberClassWithDef class SingleMemberClassAcceptDefClass { } ++ @SingleMemberEnumWithDef class SingleMemberEnumAcceptDefClass { } ++ ++ // Single member array (empty array) ++ @SingleMemberByteArray({}) class SingleMemberByteArrEmptyClass { } ++ @SingleMemberShortArray({}) class SingleMemberShortArrEmptyClass { } ++ @SingleMemberIntArray({}) class SingleMemberIntArrEmptyClass { } ++ @SingleMemberLongArray({}) class SingleMemberLongArrEmptyClass { } ++ @SingleMemberCharArray({}) class SingleMemberCharArrEmptyClass { } ++ @SingleMemberFloatArray({}) class SingleMemberFloatArrEmptyClass { } ++ @SingleMemberDoubleArray({}) class SingleMemberDoubleArrEmptyClass { } ++ @SingleMemberBooleanArray({})class SingleMemberBooleanArrEmptyClass { } ++ @SingleMemberStringArray({}) class SingleMemberStringArrEmptyClass { } ++ @SingleMemberClassArray({}) class SingleMemberClassArrEmptyClass { } ++ @SingleMemberEnumArray({}) class SingleMemberEnumArrEmptyClass { } ++ ++ // Single member array (one-element shorthand) ++ @SingleMemberByteArray(1) class SingleMemberByteArrOneClass { } ++ @SingleMemberShortArray(2) class SingleMemberShortArrOneClass { } ++ @SingleMemberIntArray(3) class SingleMemberIntArrOneClass { } ++ @SingleMemberLongArray(4L) class SingleMemberLongArrOneClass { } ++ @SingleMemberCharArray('5') class SingleMemberCharArrOneClass { } ++ @SingleMemberFloatArray(6.0f) class SingleMemberFloatArrOneClass { } ++ @SingleMemberDoubleArray(7.0) class SingleMemberDoubleArrOneClass { } ++ @SingleMemberBooleanArray(true) class SingleMemberBooleanArrOneClass { } ++ @SingleMemberStringArray("custom") class SingleMemberStringArrOneClass { } ++ @SingleMemberClassArray(Map.class) class SingleMemberClassArrOneClass { } ++ @SingleMemberEnumArray(Stooge.MOE) class SingleMemberEnumArrOneClass { } ++ ++ // Single member array (two elements) ++ @SingleMemberByteArray({1, 2}) class SingleMemberByteArrTwoClass { } ++ @SingleMemberShortArray({2, 3}) class SingleMemberShortArrTwoClass { } ++ @SingleMemberIntArray({3, 4}) class SingleMemberIntArrTwoClass { } ++ @SingleMemberLongArray({4L, 5L}) class SingleMemberLongArrTwoClass { } ++ @SingleMemberCharArray({'5', '6'}) class SingleMemberCharArrTwoClass { } ++ @SingleMemberFloatArray({6.0f, 7.0f}) class SingleMemberFloatArrTwoClass { } ++ @SingleMemberDoubleArray({7.0, 8.0}) class SingleMemberDoubleArrTwoClass { } ++ @SingleMemberBooleanArray({true,false}) class SingleMemberBooleanArrTwoClass { } ++ @SingleMemberStringArray({"custom", "paint"}) class SingleMemberStringArrTwoClass { } ++ @SingleMemberClassArray({Map.class, Set.class}) class SingleMemberClassArrTwoClass { } ++ @SingleMemberEnumArray({Stooge.MOE, Stooge.CURLY}) class SingleMemberEnumArrTwoClass { } ++ ++ // Single member array with default (override) ++ @SingleMemberByteArrayDef(1) class SingleMemberByteArrOvrdDefClass { } ++ @SingleMemberShortArrayDef(2) class SingleMemberShortArrOvrdDefClass { } ++ @SingleMemberIntArrayDef(3) class SingleMemberIntArrOvrdDefClass { } ++ @SingleMemberLongArrayDef(4L) class SingleMemberLongArrOvrdDefClass { } ++ @SingleMemberCharArrayDef('5') class SingleMemberCharArrOvrdDefClass { } ++ @SingleMemberFloatArrayDef(6.0f) class SingleMemberFloatArrOvrdDefClass { } ++ @SingleMemberDoubleArrayDef(7.0) class SingleMemberDoubleArrOvrdDefClass { } ++ @SingleMemberBooleanArrayDef(true) class SingleMemberBooleanArrOvrdDefClass { } ++ @SingleMemberStringArrayDef("custom") class SingleMemberStringArrOvrdDefClass { } ++ @SingleMemberClassArrayDef(Map.class) class SingleMemberClassArrOvrdDefClass { } ++ @SingleMemberEnumArrayDef(Stooge.MOE) class SingleMemberEnumArrOvrdDefClass { } ++ ++ // Single member array with default - accept ++ @SingleMemberByteArrayDef class SingleMemberByteArrAcceptDefClass { } ++ @SingleMemberShortArrayDef class SingleMemberShortArrAcceptDefClass { } ++ @SingleMemberIntArrayDef class SingleMemberIntArrAcceptDefClass { } ++ @SingleMemberLongArrayDef class SingleMemberLongArrAcceptDefClass { } ++ @SingleMemberCharArrayDef class SingleMemberCharArrAcceptDefClass { } ++ @SingleMemberFloatArrayDef class SingleMemberFloatArrAcceptDefClass { } ++ @SingleMemberDoubleArrayDef class SingleMemberDoubleArrAcceptDefClass { } ++ @SingleMemberBooleanArrayDef class SingleMemberBooleanArrAcceptDefClass { } ++ @SingleMemberStringArrayDef class SingleMemberStringArrAcceptDefClass { } ++ @SingleMemberClassArrayDef class SingleMemberClassArrAcceptDefClass { } ++ @SingleMemberEnumArrayDef class SingleMemberEnumArrAcceptDefClass { } ++ ++ // Annotated classes for inheritance and declared-annotations tests ++ @Foo @Bar class Grandpa { } ++ class Dad extends Grandpa { } ++ @Bar class Son extends Dad { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/bidi-tests.patch Wed Feb 11 02:18:27 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; ++ } ++ } ++ } ++} +