--- /dev/null Mon Jan 26 16:11:16 2009 +++ new/test/java/lang/Boolean/Factory.java Mon Jan 26 16:11:15 2009 @@ -0,0 +1,37 @@ +/* + * Copyright 2000 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 4262398 + * @summary Basic test for Boolean.valueOf(boolean b). + */ + +public class Factory { + public static void main(String[] args) throws Exception { + if (Boolean.valueOf(true) != Boolean.TRUE) + throw new Exception("Truth failure"); + if (Boolean.valueOf(false) != Boolean.FALSE) + throw new Exception("Major fallacy"); + } +} --- /dev/null Mon Jan 26 16:11:19 2009 +++ new/test/java/lang/Boolean/GetBoolean.java Mon Jan 26 16:11:18 2009 @@ -0,0 +1,35 @@ +/* + * Copyright 1999 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 4252308 + * @summary test Boolean.getBoolean method with empty key + */ + +public class GetBoolean { + public static void main(String[] args) throws Exception { + Boolean.getBoolean(""); + Boolean.getBoolean(null); + } +} --- /dev/null Mon Jan 26 16:11:21 2009 +++ new/test/java/lang/Boolean/MakeBooleanComparable.java Mon Jan 26 16:11:20 2009 @@ -0,0 +1,57 @@ +/* + * Copyright 2003 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 4329937 + * @summary Basic test for making Boolean implement Comparable + * @author Josh Bloch + * + * @compile -source 1.5 MakeBooleanComparable.java + * @run main MakeBooleanComparable + */ + +import java.util.*; + +public class MakeBooleanComparable { + public static void main(String args[]) { + Random rnd = new Random(); + List list = new ArrayList(); + int numFalse = 0; + for (int i = 0; i < 1000; i++) { + boolean element = rnd.nextBoolean(); + if (!element) + numFalse++; + list.add(element); // Autoboxing! + } + + Collections.sort(list); + + for (int i = 0; i < numFalse; i++) + if (list.get(i).booleanValue()) // Autounboxing doesn't work yet! + throw new RuntimeException("False positive: " + i); + for (int i = numFalse; i < 1000; i++) + if (!list.get(i).booleanValue()) // Autounboxing doesn't work yet! + throw new RuntimeException("False negative: " + i); + } +} --- /dev/null Mon Jan 26 16:11:23 2009 +++ new/test/java/lang/Boolean/ParseBoolean.java Mon Jan 26 16:11:22 2009 @@ -0,0 +1,53 @@ +/* + * Copyright 2003 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 4253773 + * @summary test Boolean.parseBoolean + */ + +public class ParseBoolean { + public static void main(String[] args) throws Exception { + checkTrue(Boolean.parseBoolean("TRUE")); + checkTrue(Boolean.parseBoolean("true")); + checkTrue(Boolean.parseBoolean("TrUe")); + + checkFalse(Boolean.parseBoolean("false")); + checkFalse(Boolean.parseBoolean("FALSE")); + checkFalse(Boolean.parseBoolean("FaLse")); + checkFalse(Boolean.parseBoolean(null)); + checkFalse(Boolean.parseBoolean("garbage")); + checkFalse(Boolean.parseBoolean("TRUEE")); + } + + static void checkTrue(boolean b) { + if (!b) + throw new RuntimeException("test failed"); + } + + static void checkFalse(boolean b) { + if (b) + throw new RuntimeException("test failed"); + } +} --- /dev/null Mon Jan 26 16:11:26 2009 +++ new/test/java/lang/Byte/Decode.java Mon Jan 26 16:11:25 2009 @@ -0,0 +1,98 @@ +/* + * Copyright 1999-2007 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 4242173 5017980 6576055 + * @summary Test Byte.decode method + * @author madbot + * @author Joseph D. Darcy + */ + +/** + * There are six methods in java.lang.Byte which transform strings + * into a byte or Byte value: + * + * public Byte(String s) + * public static Byte decode(String nm) + * public static byte parseByte(String s, int radix) + * public static byte parseByte(String s) + * public static Byte valueOf(String s, int radix) + * public static Byte valueOf(String s) + * + * However, of these only decode has a nontrivial implementation + * in that class. + */ +public class Decode { + + private static void check(String val, byte expected) { + byte n = (Byte.decode(val)).byteValue(); + if (n != expected) + throw new RuntimeException("Byte.decode failed. String:" + + val + " Result:" + n); + } + + private static void checkFailure(String val, String message) { + try { + byte n = (Byte.decode(val)).byteValue(); + throw new RuntimeException(message); + } catch (NumberFormatException e) { /* Okay */} + } + + public static void main(String[] args) throws Exception { + check(new String(""+Byte.MIN_VALUE), Byte.MIN_VALUE); + check(new String(""+Byte.MAX_VALUE), Byte.MAX_VALUE); + + check("10", (byte)10); + check("0x10", (byte)16); + check("0X10", (byte)16); + check("010", (byte)8); + check("#10", (byte)16); + + check("+10", (byte)10); + check("+0x10", (byte)16); + check("+0X10", (byte)16); + check("+010", (byte)8); + check("+#10", (byte)16); + + check("-10", (byte)-10); + check("-0x10", (byte)-16); + check("-0X10", (byte)-16); + check("-010", (byte)-8); + check("-#10", (byte)-16); + + check(Integer.toString((int)Byte.MIN_VALUE), Byte.MIN_VALUE); + check(Integer.toString((int)Byte.MAX_VALUE), Byte.MAX_VALUE); + + checkFailure("0x-10", "Byte.decode allows negative sign in wrong position."); + checkFailure("0x+10", "Byte.decode allows positive sign in wrong position."); + + checkFailure("+", "Raw plus sign allowed."); + checkFailure("-", "Raw minus sign allowed."); + + checkFailure(Integer.toString((int)Byte.MIN_VALUE - 1), "Out of range"); + checkFailure(Integer.toString((int)Byte.MAX_VALUE + 1), "Out of range"); + + checkFailure("", "Empty String"); + } +} --- /dev/null Mon Jan 26 16:11:28 2009 +++ new/test/java/lang/Double/BitwiseConversion.java Mon Jan 26 16:11:27 2009 @@ -0,0 +1,82 @@ +/* + * 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 5037596 + * @summary Verify bitwise conversion works for non-canonical NaN values + * @author Joseph D. Darcy + */ + +import static java.lang.Double.*; +import static sun.misc.DoubleConsts.*; + +public class BitwiseConversion { + static int testNanCase(long x) { + int errors = 0; + // Strip out sign and exponent bits + long y = x & SIGNIF_BIT_MASK; + + double values[] = { + longBitsToDouble(EXP_BIT_MASK | y), + longBitsToDouble(SIGN_BIT_MASK | EXP_BIT_MASK | y) + }; + + for(double value: values) { + if (!isNaN(value)) { + throw new RuntimeException("Invalid input " + y + + "yielded non-NaN" + value); + } + long converted = doubleToLongBits(value); + if (converted != 0x7ff8000000000000L) { + errors++; + System.err.format("Non-canoncial NaN bits returned: %x%n", + converted); + } + } + return errors; + } + + public static void main(String... argv) { + int errors = 0; + + for (int i = 0; i < SIGNIFICAND_WIDTH-1; i++) { + errors += testNanCase(1L< 0) + throw new RuntimeException(); + } +} --- /dev/null Mon Jan 26 16:11:31 2009 +++ new/test/java/lang/Double/Constants.java Mon Jan 26 16:11:29 2009 @@ -0,0 +1,69 @@ +/* + * Copyright 2001-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 + * @compile Constants.java + * @bug 4397405 4826652 + * @summary Testing constant-ness of Double.{MIN_VALUE, MAX_VALUE}, etc. + * @author Joseph D. Darcy + */ + +public class Constants { + /* + * This compile-only test is to make sure that the primitive + * public static final fields in java.lang.Double are "constant + * expressions" as defined by "The Java Language Specification, + * 2nd edition" section 15.28; a different test checks the values + * of those fields. + */ + public static void main(String[] args) throws Exception { + int i = 0; + switch (i) { + case (int)Double.NaN: // 0 + System.out.println("Double.NaN is a constant!"); + break; + case (int)Double.MIN_VALUE + 1: // 0 + 1 + System.out.println("Double.MIN_VALUE is a constant!"); + break; + case (int)Double.MIN_NORMAL + 2: // 0 + 2 + System.out.println("Double.MIN_NORMAL is a constant!"); + break; + case Double.MIN_EXPONENT: // -1022 + System.out.println("Double.MIN_EXPONENT is a constant!"); + break; + case Double.MAX_EXPONENT: // 1023 + System.out.println("Double.MAX_EXPONENT is a constant!"); + break; + case (int)Double.MAX_VALUE - 1: // Integer.MAX_VALUE - 1 + System.out.println("Double.MAX_VALUE is a constant!"); + break; + case (int)Double.POSITIVE_INFINITY: // Integer.MAX_VALUE + System.out.println("Double.POSITIVE_INFINITY is a constant!"); + break; + case (int)Double.NEGATIVE_INFINITY: // Integer.MIN_VALUE + System.out.println("Double.NEGATIVE_INFINITY is a constant!"); + break; + } + } +} --- /dev/null Mon Jan 26 16:11:33 2009 +++ new/test/java/lang/Double/Extrema.java Mon Jan 26 16:11:32 2009 @@ -0,0 +1,45 @@ +/* + * Copyright 2001-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 4408489 4826652 + * @summary Testing values of Double.{MIN_VALUE, MIN_NORMAL, MAX_VALUE} + * @author Joseph D. Darcy + */ + +public class Extrema { + public static void main(String[] args) throws Exception { + if (Double.MIN_VALUE != Double.longBitsToDouble(0x1L)) + throw new RuntimeException("Double.MIN_VALUE is not equal "+ + "to longBitsToDouble(0x1L)."); + + if (Double.MIN_NORMAL != Double.longBitsToDouble(0x0010000000000000L)) + throw new RuntimeException("Double.MIN_NORMAL is not equal "+ + "to longBitsToDouble(0x0010000000000000L)."); + + if (Double.MAX_VALUE != Double.longBitsToDouble(0x7fefffffffffffffL)) + throw new RuntimeException("Double.MAX_VALUE is not equal "+ + "to longBitsToDouble(0x7fefffffffffffffL)."); + } +} --- /dev/null Mon Jan 26 16:11:35 2009 +++ new/test/java/lang/Double/NaNInfinityParsing.java Mon Jan 26 16:11:34 2009 @@ -0,0 +1,169 @@ +/* + * Copyright 2001 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 4428772 + * @summary Testing recognition of "NaN" and "Infinity" strings + * @author Joseph D. Darcy + */ + + +public class NaNInfinityParsing { + /* + * Regression tests for: + * 4428772 -- Establish invariant for Float & Double classes and + * their string representations + * + * Added capability for parse{Float, Double} and related methods + * to recognize "NaN" and "Infinity" strings so that + * parseDouble(toString(d)) will always return the original + * floating-point value. + */ + + static String NaNStrings[] = { + "NaN", + "+NaN", + "-NaN" + }; + + static String infinityStrings[] = { + "Infinity", + "+Infinity", + "-Infinity", + }; + + static String invalidStrings[] = { + "+", + "-", + "@", + "N", + "Na", + "Nan", + "NaNf", + "NaNd", + "NaNF", + "NaND", + "+N", + "+Na", + "+Nan", + "+NaNf", + "+NaNd", + "+NaNF", + "+NaND", + "-N", + "-Na", + "-Nan", + "-NaNf", + "-NaNd", + "-NaNF", + "-NaND", + "I", + "In", + "Inf", + "Infi", + "Infin", + "Infini", + "Infinit", + "InfinitY", + "Infinityf", + "InfinityF", + "Infinityd", + "InfinityD", + "+I", + "+In", + "+Inf", + "+Infi", + "+Infin", + "+Infini", + "+Infinit", + "+InfinitY", + "+Infinityf", + "+InfinityF", + "+Infinityd", + "+InfinityD", + "-I", + "-In", + "-Inf", + "-Infi", + "-Infin", + "-Infini", + "-Infinit", + "-InfinitY", + "-Infinityf", + "-InfinityF", + "-Infinityd", + "-InfinityD", + "NaNInfinity", + "InfinityNaN", + "nan", + "infinity" + }; + + public static void main(String [] argv) throws Exception { + int i; + double d; + + // Test valid NaN strings + for(i = 0; i < NaNStrings.length; i++) { + if(!Double.isNaN(d=Double.parseDouble(NaNStrings[i]))) { + throw new RuntimeException("NaN string ``" + NaNStrings[i] + + "'' did not parse as a NaN; returned " + + d + " instead."); + } + } + + // Test valid Infinity strings + for(i = 0; i < infinityStrings.length; i++) { + if(!Double.isInfinite(d=Double.parseDouble(infinityStrings[i]))) { + throw new RuntimeException("Infinity string ``" + + infinityStrings[i] + + "'' did not parse as infinity; returned " + + d + "instead."); + } + // check sign of result + + boolean negative = (infinityStrings[i].charAt(0) == '-'); + if(d != (negative?Double.NEGATIVE_INFINITY: + Double.POSITIVE_INFINITY)) + throw new RuntimeException("Infinity has wrong sign;" + + (negative?"positive instead of negative.": + "negative instead of positive.")); + } + + // Test almost valid strings + for(i = 0; i < invalidStrings.length; i++) { + try { + double result; + d = Double.parseDouble(invalidStrings[i]); + throw new RuntimeException("Invalid string ``" + + invalidStrings[i] + +"'' parsed as " + d + "."); + } + catch(NumberFormatException e) { + // expected + } + } + + } +} --- /dev/null Mon Jan 26 16:11:37 2009 +++ new/test/java/lang/Double/ParseDouble.java Mon Jan 26 16:11:36 2009 @@ -0,0 +1,562 @@ +/* + * Copyright 2001-2003 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 4160406 4705734 4707389 4826774 4895911 + * @summary Test for Double.parseDouble method and acceptance regex + */ + +import java.util.regex.*; + +public class ParseDouble { + + private static void check(String val, double expected) { + double n = Double.parseDouble(val); + if (n != expected) + throw new RuntimeException("Double.parseDouble failed. String:" + + val + " Result:" + n); + } + + private static void rudimentaryTest() { + check(new String(""+Double.MIN_VALUE), Double.MIN_VALUE); + check(new String(""+Double.MAX_VALUE), Double.MAX_VALUE); + + check("10", (double) 10.0); + check("10.0", (double) 10.0); + check("10.01", (double) 10.01); + + check("-10", (double) -10.0); + check("-10.00", (double) -10.0); + check("-10.01", (double) -10.01); + } + + + static String badStrings[] = { + "", + "+", + "-", + "+e", + "-e", + "+e170", + "-e170", + + // Make sure intermediate white space is not deleted. + "1234 e10", + "-1234 e10", + + // Control characters in the interior of a string are not legal + "1\u0007e1", + "1e\u00071", + + // NaN and infinity can't have trailing type suffices or exponents + "NaNf", + "NaNF", + "NaNd", + "NaND", + "-NaNf", + "-NaNF", + "-NaNd", + "-NaND", + "+NaNf", + "+NaNF", + "+NaNd", + "+NaND", + "Infinityf", + "InfinityF", + "Infinityd", + "InfinityD", + "-Infinityf", + "-InfinityF", + "-Infinityd", + "-InfinityD", + "+Infinityf", + "+InfinityF", + "+Infinityd", + "+InfinityD", + + "NaNe10", + "-NaNe10", + "+NaNe10", + "Infinitye10", + "-Infinitye10", + "+Infinitye10", + + // Non-ASCII digits are not recognized + "\u0661e\u0661", // 1e1 in Arabic-Indic digits + "\u06F1e\u06F1", // 1e1 in Extended Arabic-Indic digits + "\u0967e\u0967", // 1e1 in Devanagari digits + + // JCK test lex03592m3 + ".", + + // JCK test lex03592m4 + "e42", + + // JCK test lex03592m5 + ".e42", + + // JCK test lex03592m6 + "d", + + // JCK test lex03592m7 + ".d", + + // JCK test lex03592m8 + "e42d", + + // JCK test lex03592m9 + ".e42d", + + // JCK test lex03593m10 + "1A01.01125e-10d", + + // JCK test lex03593m11 + "2;3.01125e-10d", + + // JCK test lex03593m12 + "1_34.01125e-10d", + + // JCK test lex03593m14 + "202..01125e-10d", + + // JCK test lex03593m15 + "202,01125e-10d", + + // JCK test lex03593m16 + "202.03b4e-10d", + + // JCK test lex03593m18 + "202.06_3e-10d", + + // JCK test lex03593m20 + "202.01125e-f0d", + + // JCK test lex03593m21 + "202.01125e_3d", + + // JCK test lex03593m22 + "202.01125e -5d", + + // JCK test lex03593m24 + "202.01125e-10r", + + // JCK test lex03593m25 + "202.01125e-10ff", + + // JCK test lex03593m26 + "1234L.01", + + // JCK test lex03593m27 + "12ee-2", + + // JCK test lex03593m28 + "12e-2.2.2", + + // JCK test lex03593m29 + "12.01e+", + + // JCK test lex03593m30 + "12.01E", + + // Bad hexadecimal-style strings + + // Two leading zeros + "00x1.0p1", + + // Must have hex specifier + "1.0p1", + "00010p1", + "deadbeefp1", + + // Need an explicit fully-formed exponent + "0x1.0p", + "0x1.0", + + // Exponent must be in decimal + "0x1.0pa", + "0x1.0pf", + + // Exponent separated by "p" + "0x1.0e22", + "0x1.0e22", + + // Need a signifcand + "0xp22" + }; + + static String goodStrings[] = { + "NaN", + "+NaN", + "-NaN", + "Infinity", + "+Infinity", + "-Infinity", + "1.1e-23f", + ".1e-23f", + "1e-23", + "1f", + "0", + "-0", + "+0", + "00", + "00", + "-00", + "+00", + "0000000000", + "-0000000000", + "+0000000000", + "1", + "2", + "1234", + "-1234", + "+1234", + "2147483647", // Integer.MAX_VALUE + "2147483648", + "-2147483648", // Integer.MIN_VALUE + "-2147483649", + + "16777215", + "16777216", // 2^24 + "16777217", + + "-16777215", + "-16777216", // -2^24 + "-16777217", + + "9007199254740991", + "9007199254740992", // 2^53 + "9007199254740993", + + "-9007199254740991", + "-9007199254740992", // -2^53 + "-9007199254740993", + + "9223372036854775807", + "9223372036854775808", // Long.MAX_VALUE + "9223372036854775809", + + "-9223372036854775808", + "-9223372036854775809", // Long.MIN_VALUE + "-9223372036854775810", + + // Culled from JCK test lex03591m1 + "54.07140d", + "7.01e-324d", + "2147483647.01d", + "1.2147483647f", + "000000000000000000000000001.F", + "1.00000000000000000000000000e-2F", + + // Culled from JCK test lex03592m2 + "2.", + ".0909", + "122112217090.0", + "7090e-5", + "2.E-20", + ".0909e42", + "122112217090.0E+100", + "7090f", + "2.F", + ".0909d", + "122112217090.0D", + "7090e-5f", + "2.E-20F", + ".0909e42d", + "122112217090.0E+100D", + + // Culled from JCK test lex03594m31 -- unicode escapes + "\u0035\u0031\u0034\u0039\u0032\u0033\u0036\u0037\u0038\u0030.1102E-209D", + "1290873\u002E12301e100", + "1.1E-10\u0066", + + // Culled from JCK test lex03595m1 + "0.0E-10", + "1E10", + + // Culled from JCK test lex03691m1 + "0.f", + "1f", + "0.F", + "1F", + "0.12d", + "1e-0d", + "12.e+1D", + "0e-0D", + "12.e+01", + "1e-01", + + // Good hex strings + // Vary capitalization of separators. + + "0x1p1", + "0X1p1", + "0x1P1", + "0X1P1", + "0x1p1f", + "0X1p1f", + "0x1P1f", + "0X1P1f", + "0x1p1F", + "0X1p1F", + "0x1P1F", + "0X1P1F", + "0x1p1d", + "0X1p1d", + "0x1P1d", + "0X1P1d", + "0x1p1D", + "0X1p1D", + "0x1P1D", + "0X1P1D", + + "-0x1p1", + "-0X1p1", + "-0x1P1", + "-0X1P1", + "-0x1p1f", + "-0X1p1f", + "-0x1P1f", + "-0X1P1f", + "-0x1p1F", + "-0X1p1F", + "-0x1P1F", + "-0X1P1F", + "-0x1p1d", + "-0X1p1d", + "-0x1P1d", + "-0X1P1d", + "-0x1p1D", + "-0X1p1D", + "-0x1P1D", + "-0X1P1D", + + "0x1p-1", + "0X1p-1", + "0x1P-1", + "0X1P-1", + "0x1p-1f", + "0X1p-1f", + "0x1P-1f", + "0X1P-1f", + "0x1p-1F", + "0X1p-1F", + "0x1P-1F", + "0X1P-1F", + "0x1p-1d", + "0X1p-1d", + "0x1P-1d", + "0X1P-1d", + "0x1p-1D", + "0X1p-1D", + "0x1P-1D", + "0X1P-1D", + + "-0x1p-1", + "-0X1p-1", + "-0x1P-1", + "-0X1P-1", + "-0x1p-1f", + "-0X1p-1f", + "-0x1P-1f", + "-0X1P-1f", + "-0x1p-1F", + "-0X1p-1F", + "-0x1P-1F", + "-0X1P-1F", + "-0x1p-1d", + "-0X1p-1d", + "-0x1P-1d", + "-0X1P-1d", + "-0x1p-1D", + "-0X1p-1D", + "-0x1P-1D", + "-0X1P-1D", + + + // Try different significand combinations + "0xap1", + "0xbp1", + "0xcp1", + "0xdp1", + "0xep1", + "0xfp1", + + "0x1p1", + "0x.1p1", + "0x1.1p1", + + "0x001p23", + "0x00.1p1", + "0x001.1p1", + + "0x100p1", + "0x.100p1", + "0x1.100p1", + + "0x00100p1", + "0x00.100p1", + "0x001.100p1" + }; + + static String paddedBadStrings[]; + static String paddedGoodStrings[]; + static { + String pad = " \t\n\r\f\u0001\u000b\u001f"; + paddedBadStrings = new String[badStrings.length]; + for(int i = 0 ; i < badStrings.length; i++) + paddedBadStrings[i] = pad + badStrings[i] + pad; + + paddedGoodStrings = new String[goodStrings.length]; + for(int i = 0 ; i < goodStrings.length; i++) + paddedGoodStrings[i] = pad + goodStrings[i] + pad; + + } + + + /* + * Throws an exception if Input is + * exceptionalInput and {@link Double.parseDouble + * parseDouble} does not throw an exception or if + * Input is not exceptionalInput and + * parseDouble throws an exception. This method does + * not attempt to test whether the string is converted to the + * proper value; just whether the input is accepted appropriately + * or not. + */ + private static void testParsing(String [] input, + boolean exceptionalInput) { + for(int i = 0; i < input.length; i++) { + double d; + + try { + d = Double.parseDouble(input[i]); + } + catch (NumberFormatException e) { + if (! exceptionalInput) { + throw new RuntimeException("Double.parseDouble rejected " + + "good string `" + input[i] + + "'."); + } + break; + } + if (exceptionalInput) { + throw new RuntimeException("Double.parseDouble accepted " + + "bad string `" + input[i] + + "'."); + } + } + } + + /* + * Throws an exception if Input is + * exceptionalInput and the regular expression + * matches one of the strings or if Input is not + * exceptionalInput and the regular expression fails + * to match an input string. + */ + private static void testRegex(String [] input, boolean exceptionalInput) { + /* + * The regex below is taken from the JavaDoc for + * Double.valueOf. + */ + + final String Digits = "(\\p{Digit}+)"; + final String HexDigits = "(\\p{XDigit}+)"; + // an exponent is 'e' or 'E' followed by an optionally + // signed decimal integer. + final String Exp = "[eE][+-]?"+Digits; + final String fpRegex = + ("[\\x00-\\x20]*"+ // Optional leading "whitespace" + "[+-]?(" + // Optional sign character + "NaN|" + // "NaN" string + "Infinity|" + // "Infinity" string + + // A floating-point string representing a finite positive + // number without a leading sign has at most five basic pieces: + // Digits . Digits ExponentPart FloatTypeSuffix + // + // Since this method allows integer-only strings as input + // in addition to strings of floating-point literals, the + // two sub-patterns below are simplifications of the grammar + // productions from the Java Language Specification, 2nd + // edition, section 3.10.2. + + + // A decimal floating-point string representing a finite positive + // number without a leading sign has at most five basic pieces: + // Digits . Digits ExponentPart FloatTypeSuffix + // + // Since this method allows integer-only strings as input + // in addition to strings of floating-point literals, the + // two sub-patterns below are simplifications of the grammar + // productions from the Java Language Specification, 2nd + // edition, section 3.10.2. + + // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt + "(((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+ + + // . Digits ExponentPart_opt FloatTypeSuffix_opt + "(\\.("+Digits+")("+Exp+")?))|"+ + + // Hexadecimal strings + "((" + + // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt + "(0[xX]" + HexDigits + "(\\.)?)|" + + + // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt + "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" + + + ")[pP][+-]?" + Digits + "))" + + "[fFdD]?))" + + "[\\x00-\\x20]*");// Optional trailing "whitespace" + Pattern fpPattern = Pattern.compile(fpRegex); + + for(int i = 0; i < input.length; i++) { + Matcher m = fpPattern.matcher(input[i]); + if (m.matches() != ! exceptionalInput) { + throw new RuntimeException("Regular expression " + + (exceptionalInput? + "accepted bad": + "rejected good") + + " string `" + + input[i] + "'."); + } + } + + } + + public static void main(String[] args) throws Exception { + rudimentaryTest(); + + testParsing(goodStrings, false); + testParsing(paddedGoodStrings, false); + testParsing(badStrings, true); + testParsing(paddedBadStrings, true); + + testRegex(goodStrings, false); + testRegex(paddedGoodStrings, false); + testRegex(badStrings, true); + testRegex(paddedBadStrings, true); + } +} --- /dev/null Mon Jan 26 16:11:40 2009 +++ new/test/java/lang/Double/ParseHexFloatingPoint.java Mon Jan 26 16:11:39 2009 @@ -0,0 +1,448 @@ +/* + * Copyright 2003 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 4826774 + * @summary Numerical tests for hexadecimal inputs to parseDouble, parseFloat + * @author Joseph D. Darcy + */ + + +import java.util.regex.*; +import sun.misc.FpUtils; +import sun.misc.DoubleConsts; + +public class ParseHexFloatingPoint { + private ParseHexFloatingPoint(){} + + public static final double infinityD = Double.POSITIVE_INFINITY; + public static final double NaND = Double.NaN; + + static int test(String testName, String input, + double result, double expected) { + int failures =0; + + if (Double.compare(result, expected) != 0 ) { + System.err.println("Failure for " + testName + + ": For input " + input + + " expected " + expected + + " got " + result + "."); + } + + return failures; + } + + static int testCase(String input, double expected) { + int failures =0; + + + // Try different combination of letter components + input = input.toLowerCase(java.util.Locale.US); + + String [] suffices = {"", "f", "F", "d", "D"}; + String [] signs = {"", "-", "+"}; + + for(int i = 0; i < 2; i++) { + String s1 = input; + if(i == 1) + s1 = s1.replace('x', 'X'); + + for(int j = 0; j < 2; j++) { + String s2 = s1; + if(j == 1) + s2 = s2.replace('p', 'P'); + + for(int k = 0; k < 2; k++) { + String s3 = s2; + if(k == 1) + s3 = upperCaseHex(s3); + + + for(int m = 0; m < suffices.length; m++) { + String s4 = s3 + suffices[m]; + + + for(int n = 0; n < signs.length; n++) { + String s5 = signs[n] + s4; + + double result = Double.parseDouble(s5); + failures += test("Double.parseDouble", + s5, result, (signs[n].equals("-") ? + -expected: + expected)); + } + } + } + } + } + + return failures; + } + + static String upperCaseHex(String s) { + return s.replace('a', 'A').replace('b', 'B').replace('c', 'C'). + replace('d', 'D').replace('e','E').replace('f', 'F'); + } + + /* + * Test easy and tricky double rounding cases. + */ + static int doubleTests() { + + /* + * A String, double pair + */ + class PairSD { + public String s; + public double d; + PairSD(String s, double d) { + this.s = s; + this.d = d; + } + } + int failures = 0; + + + + // Hex strings that convert to three; test basic functionality + // of significand and exponent shift adjusts along with the + // no-op of adding leading zeros. These cases don't exercise + // the rounding code. + String leadingZeros = "0x0000000000000000000"; + String [] threeTests = { + "0x.003p12", + "0x.006p11", + "0x.00cp10", + "0x.018p9", + + "0x.3p4", + "0x.6p3", + "0x.cp2", + "0x1.8p1", + + "0x3p0", + "0x6.0p-1", + "0xc.0p-2", + "0x18.0p-3", + + "0x3000000p-24", + "0x3.0p0", + "0x3.000000p0", + }; + for(int i=0; i < threeTests.length; i++) { + String input = threeTests[i]; + failures += testCase(input, 3.0); + + input.replaceFirst("^0x", leadingZeros); + failures += testCase(input, 3.0); + } + + long bigExponents [] = { + 2*DoubleConsts.MAX_EXPONENT, + 2*DoubleConsts.MIN_EXPONENT, + + (long)Integer.MAX_VALUE-1, + (long)Integer.MAX_VALUE, + (long)Integer.MAX_VALUE+1, + + (long)Integer.MIN_VALUE-1, + (long)Integer.MIN_VALUE, + (long)Integer.MIN_VALUE+1, + + Long.MAX_VALUE-1, + Long.MAX_VALUE, + + Long.MIN_VALUE+1, + Long.MIN_VALUE, + }; + + // Test zero significand with large exponents. + for(int i = 0; i < bigExponents.length; i++) { + failures += testCase("0x0.0p"+Long.toString(bigExponents[i]) , 0.0); + } + + // Test nonzero significand with large exponents. + for(int i = 0; i < bigExponents.length; i++) { + long exponent = bigExponents[i]; + failures += testCase("0x10000.0p"+Long.toString(exponent) , + (exponent <0?0.0:infinityD)); + } + + // Test significands with different lengths and bit patterns. + { + long signif = 0; + for(int i = 1; i <= 0xe; i++) { + signif = (signif <<4) | (long)i; + failures += testCase("0x"+Long.toHexString(signif)+"p0", signif); + } + } + + PairSD [] testCases = { + new PairSD("0x0.0p0", 0.0/16.0), + new PairSD("0x0.1p0", 1.0/16.0), + new PairSD("0x0.2p0", 2.0/16.0), + new PairSD("0x0.3p0", 3.0/16.0), + new PairSD("0x0.4p0", 4.0/16.0), + new PairSD("0x0.5p0", 5.0/16.0), + new PairSD("0x0.6p0", 6.0/16.0), + new PairSD("0x0.7p0", 7.0/16.0), + new PairSD("0x0.8p0", 8.0/16.0), + new PairSD("0x0.9p0", 9.0/16.0), + new PairSD("0x0.ap0", 10.0/16.0), + new PairSD("0x0.bp0", 11.0/16.0), + new PairSD("0x0.cp0", 12.0/16.0), + new PairSD("0x0.dp0", 13.0/16.0), + new PairSD("0x0.ep0", 14.0/16.0), + new PairSD("0x0.fp0", 15.0/16.0), + + // Half-way case between zero and MIN_VALUE rounds down to + // zero + new PairSD("0x1.0p-1075", 0.0), + + // Slighly more than half-way case between zero and + // MIN_VALUES rounds up to zero. + new PairSD("0x1.1p-1075", Double.MIN_VALUE), + new PairSD("0x1.000000000001p-1075", Double.MIN_VALUE), + new PairSD("0x1.000000000000001p-1075", Double.MIN_VALUE), + + // More subnormal rounding tests + new PairSD("0x0.fffffffffffff7fffffp-1022", FpUtils.nextDown(DoubleConsts.MIN_NORMAL)), + new PairSD("0x0.fffffffffffff8p-1022", DoubleConsts.MIN_NORMAL), + new PairSD("0x0.fffffffffffff800000001p-1022",DoubleConsts.MIN_NORMAL), + new PairSD("0x0.fffffffffffff80000000000000001p-1022",DoubleConsts.MIN_NORMAL), + new PairSD("0x1.0p-1022", DoubleConsts.MIN_NORMAL), + + + // Large value and overflow rounding tests + new PairSD("0x1.fffffffffffffp1023", Double.MAX_VALUE), + new PairSD("0x1.fffffffffffff0000000p1023", Double.MAX_VALUE), + new PairSD("0x1.fffffffffffff4p1023", Double.MAX_VALUE), + new PairSD("0x1.fffffffffffff7fffffp1023", Double.MAX_VALUE), + new PairSD("0x1.fffffffffffff8p1023", infinityD), + new PairSD("0x1.fffffffffffff8000001p1023", infinityD), + + new PairSD("0x1.ffffffffffffep1023", FpUtils.nextDown(Double.MAX_VALUE)), + new PairSD("0x1.ffffffffffffe0000p1023", FpUtils.nextDown(Double.MAX_VALUE)), + new PairSD("0x1.ffffffffffffe8p1023", FpUtils.nextDown(Double.MAX_VALUE)), + new PairSD("0x1.ffffffffffffe7p1023", FpUtils.nextDown(Double.MAX_VALUE)), + new PairSD("0x1.ffffffffffffeffffffp1023", Double.MAX_VALUE), + new PairSD("0x1.ffffffffffffe8000001p1023", Double.MAX_VALUE), + }; + + for (int i = 0; i < testCases.length; i++) { + failures += testCase(testCases[i].s,testCases[i].d); + } + + failures += significandAlignmentTests(); + + { + java.util.Random rand = new java.util.Random(); + // Consistency check; double => hexadecimal => double + // preserves the original value. + for(int i = 0; i < 1000; i++) { + double d = rand.nextDouble(); + failures += testCase(Double.toHexString(d), d); + } + } + + return failures; + } + + /* + * Verify rounding works the same regardless of how the + * significand is aligned on input. A useful extension could be + * to have this sort of test for strings near the overflow + * threshold. + */ + static int significandAlignmentTests() { + int failures = 0; + // baseSignif * 2^baseExp = nextDown(2.0) + long [] baseSignifs = { + 0x1ffffffffffffe00L, + 0x1fffffffffffff00L + }; + + double [] answers = { + FpUtils.nextDown(FpUtils.nextDown(2.0)), + FpUtils.nextDown(2.0), + 2.0 + }; + + int baseExp = -60; + int count = 0; + for(int i = 0; i < 2; i++) { + for(long j = 0; j <= 0xfL; j++) { + for(long k = 0; k <= 8; k+= 4) { // k = {0, 4, 8} + long base = baseSignifs[i]; + long testValue = base | (j<<4) | k; + + int offset = 0; + // Calculate when significand should be incremented + // see table 4.7 in Koren book + + if ((base & 0x100L) == 0L ) { // lsb is 0 + if ( (j >= 8L) && // round is 1 + ((j & 0x7L) != 0 || k != 0 ) ) // sticky is 1 + offset = 1; + } + else { // lsb is 1 + if (j >= 8L) // round is 1 + offset = 1; + } + + double expected = answers[i+offset]; + + for(int m = -2; m <= 3; m++) { + count ++; + + // Form equal value string and evaluate it + String s = "0x" + + Long.toHexString((m >=0) ?(testValue<>(-m))) + + "p" + (baseExp - m); + + failures += testCase(s, expected); + } + } + } + } + + return failures; + } + + + /* + * Test tricky float rounding cases. The code which + * reads in a hex string converts the string to a double value. + * If a float value is needed, the double value is cast to float. + * However, the cast be itself not always guaranteed to return the + * right result since: + * + * 1. hex string => double can discard a sticky bit which would + * influence a direct hex string => float conversion. + * + * 2. hex string => double => float can have a rounding to double + * precision which results in a larger float value while a direct + * hex string => float conversion would not round up. + * + * This method includes tests of the latter two possibilities. + */ + static int floatTests(){ + int failures = 0; + + /* + * A String, float pair + */ + class PairSD { + public String s; + public float f; + PairSD(String s, float f) { + this.s = s; + this.f = f; + } + } + + String [][] roundingTestCases = { + // Target float value hard rouding version + + {"0x1.000000p0", "0x1.0000000000001p0"}, + + // Try some values that should round up to nextUp(1.0f) + {"0x1.000002p0", "0x1.0000010000001p0"}, + {"0x1.000002p0", "0x1.00000100000008p0"}, + {"0x1.000002p0", "0x1.0000010000000fp0"}, + {"0x1.000002p0", "0x1.00000100000001p0"}, + {"0x1.000002p0", "0x1.00000100000000000000000000000000000000001p0"}, + {"0x1.000002p0", "0x1.0000010000000fp0"}, + + // Potential double rounding cases + {"0x1.000002p0", "0x1.000002fffffffp0"}, + {"0x1.000002p0", "0x1.000002fffffff8p0"}, + {"0x1.000002p0", "0x1.000002ffffffffp0"}, + + {"0x1.000002p0", "0x1.000002ffff0ffp0"}, + {"0x1.000002p0", "0x1.000002ffff0ff8p0"}, + {"0x1.000002p0", "0x1.000002ffff0fffp0"}, + + + {"0x1.000000p0", "0x1.000000fffffffp0"}, + {"0x1.000000p0", "0x1.000000fffffff8p0"}, + {"0x1.000000p0", "0x1.000000ffffffffp0"}, + + {"0x1.000000p0", "0x1.000000ffffffep0"}, + {"0x1.000000p0", "0x1.000000ffffffe8p0"}, + {"0x1.000000p0", "0x1.000000ffffffefp0"}, + + // Float subnormal cases + {"0x0.000002p-126", "0x0.0000010000001p-126"}, + {"0x0.000002p-126", "0x0.00000100000000000001p-126"}, + + {"0x0.000006p-126", "0x0.0000050000001p-126"}, + {"0x0.000006p-126", "0x0.00000500000000000001p-126"}, + + {"0x0.0p-149", "0x0.7ffffffffffffffp-149"}, + {"0x1.0p-148", "0x1.3ffffffffffffffp-148"}, + {"0x1.cp-147", "0x1.bffffffffffffffp-147"}, + + {"0x1.fffffcp-127", "0x1.fffffdffffffffp-127"}, + }; + + String [] signs = {"", "-"}; + + for(int i = 0; i < roundingTestCases.length; i++) { + for(int j = 0; j < signs.length; j++) { + String expectedIn = signs[j]+roundingTestCases[i][0]; + String resultIn = signs[j]+roundingTestCases[i][1]; + + float expected = Float.parseFloat(expectedIn); + float result = Float.parseFloat(resultIn); + + if( Float.compare(expected, result) != 0) { + failures += 1; + System.err.println("" + (i+1)); + System.err.println("Expected = " + Float.toHexString(expected)); + System.err.println("Rounded = " + Float.toHexString(result)); + System.err.println("Double = " + Double.toHexString(Double.parseDouble(resultIn))); + System.err.println("Input = " + resultIn); + System.err.println(""); + } + } + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += doubleTests(); + failures += floatTests(); + + if (failures != 0) { + throw new RuntimeException("" + failures + " failures while " + + "testing hexadecimal floating-point " + + "parsing."); + } + } + +} --- /dev/null Mon Jan 26 16:11:42 2009 +++ new/test/java/lang/Double/ToHexString.java Mon Jan 26 16:11:41 2009 @@ -0,0 +1,252 @@ +/* + * Copyright 2003 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 4826774 4926547 + * @summary Tests for {Float, Double}.toHexString methods + * @author Joseph D. Darcy + */ + +import java.util.regex.*; +import sun.misc.FpUtils; +import sun.misc.DoubleConsts; + +public class ToHexString { + private ToHexString() {} + + /* + * Given a double value, create a hexadecimal floating-point + * string via an intermediate long hex string. + */ + static String doubleToHexString(double d) { + return hexLongStringtoHexDoubleString(Long.toHexString(Double.doubleToLongBits(d))); + } + + /* + * Transform the hexadecimal long output into the equivalent + * hexadecimal double value. + */ + static String hexLongStringtoHexDoubleString(String transString) { + transString = transString.toLowerCase(); + + String zeros = ""; + StringBuffer result = new StringBuffer(24); + + for(int i = 0; i < (16 - transString.length()); i++, zeros += "0"); + transString = zeros + transString; + + // assert transString.length == 16; + + char topChar; + // Extract sign + if((topChar=transString.charAt(0)) >= '8' ) {// 8, 9, a, A, b, B, ... + result.append("-"); + // clear sign bit + transString = + Character.toString(Character.forDigit(Character.digit(topChar, 16) - 8, 16)) + + transString.substring(1,16); + } + + // check for NaN and infinity + String signifString = transString.substring(3,16); + + if( transString.substring(0,3).equals("7ff") ) { + if(signifString.equals("0000000000000")) { + result.append("Infinity"); + } + else + result.append("NaN"); + } + else { // finite value + // Extract exponent + int exponent = Integer.parseInt(transString.substring(0,3), 16) - + DoubleConsts.EXP_BIAS; + result.append("0x"); + + if (exponent == DoubleConsts.MIN_EXPONENT - 1) { // zero or subnormal + if(signifString.equals("0000000000000")) { + result.append("0.0p0"); + } + else { + result.append("0." + signifString.replaceFirst("0+$", "").replaceFirst("^$", "0") + + "p-1022"); + } + } + else { // normal value + result.append("1." + signifString.replaceFirst("0+$", "").replaceFirst("^$", "0") + + "p" + exponent); + } + } + return result.toString(); + } + + public static int toHexStringTests() { + int failures = 0; + String [][] testCases1 = { + {"Infinity", "Infinity"}, + {"-Infinity", "-Infinity"}, + {"NaN", "NaN"}, + {"-NaN", "NaN"}, + {"0.0", "0x0.0p0"}, + {"-0.0", "-0x0.0p0"}, + {"1.0", "0x1.0p0"}, + {"-1.0", "-0x1.0p0"}, + {"2.0", "0x1.0p1"}, + {"3.0", "0x1.8p1"}, + {"0.5", "0x1.0p-1"}, + {"0.25", "0x1.0p-2"}, + {"1.7976931348623157e+308", "0x1.fffffffffffffp1023"}, // MAX_VALUE + {"2.2250738585072014E-308", "0x1.0p-1022"}, // MIN_NORMAL + {"2.225073858507201E-308", "0x0.fffffffffffffp-1022"}, // MAX_SUBNORMAL + {"4.9e-324", "0x0.0000000000001p-1022"} // MIN_VALUE + }; + + // Compare decimal string -> double -> hex string to hex string + for (int i = 0; i < testCases1.length; i++) { + String result; + if(! (result=Double.toHexString(Double.parseDouble(testCases1[i][0]))). + equals(testCases1[i][1])) { + failures ++; + System.err.println("For floating-point string " + testCases1[i][0] + + ", expected hex output " + testCases1[i][1] + ", got " + result +"."); + } + } + + + // Except for float subnormals, the output for numerically + // equal float and double values should be the same. + // Therefore, we will explicitly test float subnormal values. + String [][] floatTestCases = { + {"Infinity", "Infinity"}, + {"-Infinity", "-Infinity"}, + {"NaN", "NaN"}, + {"-NaN", "NaN"}, + {"0.0", "0x0.0p0"}, + {"-0.0", "-0x0.0p0"}, + {"1.0", "0x1.0p0"}, + {"-1.0", "-0x1.0p0"}, + {"2.0", "0x1.0p1"}, + {"3.0", "0x1.8p1"}, + {"0.5", "0x1.0p-1"}, + {"0.25", "0x1.0p-2"}, + {"3.4028235e+38f", "0x1.fffffep127"}, // MAX_VALUE + {"1.17549435E-38f", "0x1.0p-126"}, // MIN_NORMAL + {"1.1754942E-38", "0x0.fffffep-126"}, // MAX_SUBNORMAL + {"1.4e-45f", "0x0.000002p-126"} // MIN_VALUE + }; + // Compare decimal string -> double -> hex string to hex string + for (int i = 0; i < floatTestCases.length; i++) { + String result; + if(! (result=Float.toHexString(Float.parseFloat(floatTestCases[i][0]))). + equals(floatTestCases[i][1])) { + failures++; + System.err.println("For floating-point string " + floatTestCases[i][0] + + ", expected hex output\n" + floatTestCases[i][1] + ", got\n" + result +"."); + } + } + + // Particular floating-point values and hex equivalents, mostly + // taken from fdlibm source. + String [][] testCases2 = { + {"+0.0", "0000000000000000"}, + {"-0.0", "8000000000000000"}, + {"+4.9e-324", "0000000000000001"}, + {"-4.9e-324", "8000000000000001"}, + + // fdlibm k_sin.c + {"+5.00000000000000000000e-01", "3FE0000000000000"}, + {"-1.66666666666666324348e-01", "BFC5555555555549"}, + {"+8.33333333332248946124e-03", "3F8111111110F8A6"}, + {"-1.98412698298579493134e-04", "BF2A01A019C161D5"}, + {"+2.75573137070700676789e-06", "3EC71DE357B1FE7D"}, + {"-2.50507602534068634195e-08", "BE5AE5E68A2B9CEB"}, + {"+1.58969099521155010221e-10", "3DE5D93A5ACFD57C"}, + + // fdlibm k_cos.c + {"+4.16666666666666019037e-02", "3FA555555555554C"}, + {"-1.38888888888741095749e-03", "BF56C16C16C15177"}, + {"+2.48015872894767294178e-05", "3EFA01A019CB1590"}, + {"-2.75573143513906633035e-07", "BE927E4F809C52AD"}, + {"+2.08757232129817482790e-09", "3E21EE9EBDB4B1C4"}, + {"-1.13596475577881948265e-11", "BDA8FAE9BE8838D4"}, + + // fdlibm e_rempio.c + {"1.67772160000000000000e+07", "4170000000000000"}, + {"6.36619772367581382433e-01", "3FE45F306DC9C883"}, + {"1.57079632673412561417e+00", "3FF921FB54400000"}, + {"6.07710050650619224932e-11", "3DD0B4611A626331"}, + {"6.07710050630396597660e-11", "3DD0B4611A600000"}, + {"2.02226624879595063154e-21", "3BA3198A2E037073"}, + {"2.02226624871116645580e-21", "3BA3198A2E000000"}, + {"8.47842766036889956997e-32", "397B839A252049C1"}, + + + // fdlibm s_cbrt.c + {"+5.42857142857142815906e-01", "3FE15F15F15F15F1"}, + {"-7.05306122448979611050e-01", "BFE691DE2532C834"}, + {"+1.41428571428571436819e+00", "3FF6A0EA0EA0EA0F"}, + {"+1.60714285714285720630e+00", "3FF9B6DB6DB6DB6E"}, + {"+3.57142857142857150787e-01", "3FD6DB6DB6DB6DB7"}, + }; + + // Compare decimal string -> double -> hex string to + // long hex string -> double hex string + for (int i = 0; i < testCases2.length; i++) { + String result; + String expected; + if(! (result=Double.toHexString(Double.parseDouble(testCases2[i][0]))). + equals( expected=hexLongStringtoHexDoubleString(testCases2[i][1]) )) { + failures ++; + System.err.println("For floating-point string " + testCases2[i][0] + + ", expected hex output " + expected + ", got " + result +"."); + } + } + + // Test random double values; + // compare double -> Double.toHexString with local doubleToHexString + java.util.Random rand = new java.util.Random(0); + for (int i = 0; i < 1000; i++) { + String result; + String expected; + double d = rand.nextDouble(); + if(! (expected=doubleToHexString(d)).equals(result=Double.toHexString(d)) ) { + failures ++; + System.err.println("For floating-point value " + d + + ", expected hex output " + expected + ", got " + result +"."); + } + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures = toHexStringTests(); + + if (failures != 0) { + throw new RuntimeException("" + failures + " failures while testing Double.toHexString"); + } + } +} --- /dev/null Mon Jan 26 16:11:44 2009 +++ new/test/java/lang/Float/BitwiseConversion.java Mon Jan 26 16:11:43 2009 @@ -0,0 +1,82 @@ +/* + * 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 5037596 + * @summary Verify bitwise conversion works for non-canonical NaN values + * @author Joseph D. Darcy + */ + +import static java.lang.Float.*; +import static sun.misc.FloatConsts.*; + +public class BitwiseConversion { + static int testNanCase(int x) { + int errors = 0; + // Strip out sign and exponent bits + int y = x & SIGNIF_BIT_MASK; + + float values[] = { + intBitsToFloat(EXP_BIT_MASK | y), + intBitsToFloat(SIGN_BIT_MASK | EXP_BIT_MASK | y) + }; + + for(float value: values) { + if (!isNaN(value)) { + throw new RuntimeException("Invalid input " + y + + "yielded non-NaN" + value); + } + int converted = floatToIntBits(value); + if (converted != 0x7fc00000) { + errors++; + System.err.format("Non-canoncial NaN bits returned: %x%n", + converted); + } + } + return errors; + } + + public static void main(String... argv) { + int errors = 0; + + for (int i = 0; i < SIGNIFICAND_WIDTH-1; i++) { + errors += testNanCase(1< 0) + throw new RuntimeException(); + } +} --- /dev/null Mon Jan 26 16:11:47 2009 +++ new/test/java/lang/Float/Constants.java Mon Jan 26 16:11:45 2009 @@ -0,0 +1,69 @@ +/* + * Copyright 2001-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 + * @compile Constants.java + * @bug 4397405 4826652 + * @summary Testing constant-ness of Float.{MIN_VALUE, MAX_VALUE}, etc. + * @author Joseph D. Darcy + */ + +public class Constants { + /* + * This compile-only test is to make sure that the primitive + * public static final fields in java.lang.Float are "constant + * expressions" as defined by "The Java Language Specification, + * 2nd edition" section 15.28; a different test checks the values + * of those fields. + */ + public static void main(String[] args) throws Exception { + int i = 0; + switch (i) { + case (int)Float.NaN: // 0 + System.out.println("Float.NaN is a constant!"); + break; + case (int)Float.MIN_VALUE + 1: // 0 + 1 + System.out.println("Float.MIN_VALUE is a constant!"); + break; + case (int)Float.MIN_NORMAL + 2: // 0 + 2 + System.out.println("Float.MIN_NORMAL is a constant!"); + break; + case Float.MIN_EXPONENT: // -126 + System.out.println("Float.MIN_EXPONENT is a constant!"); + break; + case Float.MAX_EXPONENT: // 127 + System.out.println("Float.MAX_EXPONENT is a constant!"); + break; + case (int)Float.MAX_VALUE - 1: // Integer.MAX_VALUE - 1 + System.out.println("Float.MAX_VALUE is a constant!"); + break; + case (int)Float.POSITIVE_INFINITY: // Integer.MAX_VALUE + System.out.println("Float.POSITIVE_INFINITY is a constant!"); + break; + case (int)Float.NEGATIVE_INFINITY: // Integer.MIN_VALUE + System.out.println("Float.NEGATIVE_INFINITY is a constant!"); + break; + } + } +} --- /dev/null Mon Jan 26 16:11:49 2009 +++ new/test/java/lang/Float/Extrema.java Mon Jan 26 16:11:48 2009 @@ -0,0 +1,45 @@ +/* + * Copyright 2001-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 4408489 4826652 + * @summary Testing values of Float.{MIN_VALUE, MIN_NORMAL, MAX_VALUE} + * @author Joseph D. Darcy + */ + +public class Extrema { + public static void main(String[] args) throws Exception { + if (Float.MIN_VALUE != Float.intBitsToFloat(0x1)) + throw new RuntimeException("Float.MIN_VALUE is not equal "+ + "to intBitsToFloat(0x1)."); + + if (Float.MIN_NORMAL != Float.intBitsToFloat(0x00800000)) + throw new RuntimeException("Float.MIN_NORMAL is not equal "+ + "to intBitsToFloat(0x00800000)."); + + if (Float.MAX_VALUE != Float.intBitsToFloat(0x7f7fffff)) + throw new RuntimeException("Float.MAX_VALUE is not equal "+ + "to intBitsToFloat(0x7f7fffff)."); + } +} --- /dev/null Mon Jan 26 16:11:51 2009 +++ new/test/java/lang/Float/NaNInfinityParsing.java Mon Jan 26 16:11:50 2009 @@ -0,0 +1,169 @@ +/* + * Copyright 2001 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 4428772 + * @summary Testing recognition of "NaN" and "Infinity" strings + * @author Joseph D. Darcy + */ + + +public class NaNInfinityParsing { + /* + * Regression tests for: + * 4428772 -- Establish invariant for Float & Double classes and + * their string representations + * + * Added capability for parse{Float, Double} and related methods + * to recognize "NaN" and "Infinity" strings so that + * parseFloat(toString(d)) will always return the original + * floating-point value. + */ + + static String NaNStrings[] = { + "NaN", + "+NaN", + "-NaN" + }; + + static String infinityStrings[] = { + "Infinity", + "+Infinity", + "-Infinity", + }; + + static String invalidStrings[] = { + "+", + "-", + "@", + "N", + "Na", + "Nan", + "NaNf", + "NaNd", + "NaNF", + "NaND", + "+N", + "+Na", + "+Nan", + "+NaNf", + "+NaNd", + "+NaNF", + "+NaND", + "-N", + "-Na", + "-Nan", + "-NaNf", + "-NaNd", + "-NaNF", + "-NaND", + "I", + "In", + "Inf", + "Infi", + "Infin", + "Infini", + "Infinit", + "InfinitY", + "Infinityf", + "InfinityF", + "Infinityd", + "InfinityD", + "+I", + "+In", + "+Inf", + "+Infi", + "+Infin", + "+Infini", + "+Infinit", + "+InfinitY", + "+Infinityf", + "+InfinityF", + "+Infinityd", + "+InfinityD", + "-I", + "-In", + "-Inf", + "-Infi", + "-Infin", + "-Infini", + "-Infinit", + "-InfinitY", + "-Infinityf", + "-InfinityF", + "-Infinityd", + "-InfinityD", + "NaNInfinity", + "InfinityNaN", + "nan", + "infinity" + }; + + public static void main(String [] argv) throws Exception { + int i; + float d; + + // Test valid NaN strings + for(i = 0; i < NaNStrings.length; i++) { + if(!Float.isNaN(d=Float.parseFloat(NaNStrings[i]))) { + throw new RuntimeException("NaN string ``" + NaNStrings[i] + + "'' did not parse as a NaN; returned " + + d + " instead."); + } + } + + // Test valid Infinity strings + for(i = 0; i < infinityStrings.length; i++) { + if(!Float.isInfinite(d=Float.parseFloat(infinityStrings[i]))) { + throw new RuntimeException("Infinity string ``" + + infinityStrings[i] + + "'' did not parse as infinity; returned " + + d + "instead."); + } + // check sign of result + + boolean negative = (infinityStrings[i].charAt(0) == '-'); + if(d != (negative?Float.NEGATIVE_INFINITY: + Float.POSITIVE_INFINITY)) + throw new RuntimeException("Infinity has wrong sign;" + + (negative?"positive instead of negative.": + "negative instead of positive.")); + } + + // Test almost valid strings + for(i = 0; i < invalidStrings.length; i++) { + try { + float result; + d = Float.parseFloat(invalidStrings[i]); + throw new RuntimeException("Invalid string ``" + + invalidStrings[i] + +"'' parsed as " + d + "."); + } + catch(NumberFormatException e) { + // expected + } + } + + } +} --- /dev/null Mon Jan 26 16:11:53 2009 +++ new/test/java/lang/Float/ParseFloat.java Mon Jan 26 16:11:52 2009 @@ -0,0 +1,210 @@ +/* + * Copyright 1998-2003 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 4160406 4705734 4707389 + * @summary Tests for Float.parseFloat method + */ + +public class ParseFloat { + + private static void check(String val, float expected) { + float n = Float.parseFloat(val); + if (n != expected) + throw new RuntimeException("Float.parseFloat failed. String:" + + val + " Result:" + n); + } + + private static void rudimentaryTest() { + check(new String(""+Float.MIN_VALUE), Float.MIN_VALUE); + check(new String(""+Float.MAX_VALUE), Float.MAX_VALUE); + + check("10", (float) 10.0); + check("10.0", (float) 10.0); + check("10.01", (float) 10.01); + + check("-10", (float) -10.0); + check("-10.00", (float) -10.0); + check("-10.01", (float) -10.01); + } + + static String badStrings[] = { + "", + "+", + "-", + "+e", + "-e", + "+e170", + "-e170", + + // Make sure intermediate white space is not deleted. + "1234 e10", + "-1234 e10", + + // Control characters in the interior of a string are not legal + "1\u0007e1", + "1e\u00071", + + // NaN and infinity can't have trailing type suffices or exponents + "NaNf", + "NaNF", + "NaNd", + "NaND", + "-NaNf", + "-NaNF", + "-NaNd", + "-NaND", + "+NaNf", + "+NaNF", + "+NaNd", + "+NaND", + "Infinityf", + "InfinityF", + "Infinityd", + "InfinityD", + "-Infinityf", + "-InfinityF", + "-Infinityd", + "-InfinityD", + "+Infinityf", + "+InfinityF", + "+Infinityd", + "+InfinityD", + + "NaNe10", + "-NaNe10", + "+NaNe10", + "Infinitye10", + "-Infinitye10", + "+Infinitye10", + + // Non-ASCII digits are not recognized + "\u0661e\u0661", // 1e1 in Arabic-Indic digits + "\u06F1e\u06F1", // 1e1 in Extended Arabic-Indic digits + "\u0967e\u0967" // 1e1 in Devanagari digits + }; + + static String goodStrings[] = { + "NaN", + "+NaN", + "-NaN", + "Infinity", + "+Infinity", + "-Infinity", + "1.1e-23f", + ".1e-23f", + "1e-23", + "1f", + "1", + "2", + "1234", + "-1234", + "+1234", + "2147483647", // Integer.MAX_VALUE + "2147483648", + "-2147483648", // Integer.MIN_VALUE + "-2147483649", + + "16777215", + "16777216", // 2^24 + "16777217", + + "-16777215", + "-16777216", // -2^24 + "-16777217", + + "9007199254740991", + "9007199254740992", // 2^53 + "9007199254740993", + + "-9007199254740991", + "-9007199254740992", // -2^53 + "-9007199254740993", + + "9223372036854775807", + "9223372036854775808", // Long.MAX_VALUE + "9223372036854775809", + + "-9223372036854775808", + "-9223372036854775809", // Long.MIN_VALUE + "-9223372036854775810" + }; + + static String paddedBadStrings[]; + static String paddedGoodStrings[]; + static { + String pad = " \t\n\r\f\u0001\u000b\u001f"; + paddedBadStrings = new String[badStrings.length]; + for(int i = 0 ; i < badStrings.length; i++) + paddedBadStrings[i] = pad + badStrings[i] + pad; + + paddedGoodStrings = new String[goodStrings.length]; + for(int i = 0 ; i < goodStrings.length; i++) + paddedGoodStrings[i] = pad + goodStrings[i] + pad; + + } + + /* + * Throws an exception if Input is + * exceptionalInput and {@link Float.parseFloat + * parseFloat} does not throw an exception or if + * Input is not exceptionalInput and + * parseFloat throws an exception. This method does + * not attempt to test whether the string is converted to the + * proper value; just whether the input is accepted appropriately + * or not. + */ + private static void testParsing(String [] input, + boolean exceptionalInput) { + for(int i = 0; i < input.length; i++) { + double d; + + try { + d = Float.parseFloat(input[i]); + } + catch (NumberFormatException e) { + if (! exceptionalInput) { + throw new RuntimeException("Float.parseFloat rejected " + + "good string `" + input[i] + + "'."); + } + break; + } + if (exceptionalInput) { + throw new RuntimeException("Float.parseFloat accepted " + + "bad string `" + input[i] + + "'."); + } + } + } + + public static void main(String[] args) throws Exception { + rudimentaryTest(); + + testParsing(goodStrings, false); + testParsing(paddedGoodStrings, false); + testParsing(badStrings, true); + testParsing(paddedBadStrings, true); + } +} --- /dev/null Mon Jan 26 16:11:55 2009 +++ new/test/java/lang/Integer/BitTwiddle.java Mon Jan 26 16:11:54 2009 @@ -0,0 +1,137 @@ +/* + * Copyright 2003 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 4495754 + * @summary Basic test for int bit twiddling + * @author Josh Bloch + * + * @compile -source 1.5 BitTwiddle.java + * @run main BitTwiddle + */ + +import java.util.Random; +import static java.lang.Integer.*; + +public class BitTwiddle { + private static final int N = 1000; // # of repetitions per test + + public static void main(String args[]) { + Random rnd = new Random(); + + if (highestOneBit(0) != 0) + throw new RuntimeException("a"); + if (highestOneBit(-1) != MIN_VALUE) + throw new RuntimeException("b"); + if (highestOneBit(1) != 1) + throw new RuntimeException("c"); + + if (lowestOneBit(0) != 0) + throw new RuntimeException("d"); + if (lowestOneBit(-1) != 1) + throw new RuntimeException("e"); + if (lowestOneBit(MIN_VALUE) != MIN_VALUE) + throw new RuntimeException("f"); + + for (int i = 0; i < N; i++) { + int x = rnd.nextInt(); + if (highestOneBit(x) != reverse(lowestOneBit(reverse(x)))) + throw new RuntimeException("g: " + toHexString(x)); + } + + if (numberOfLeadingZeros(0) != SIZE) + throw new RuntimeException("h"); + if (numberOfLeadingZeros(-1) != 0) + throw new RuntimeException("i"); + if (numberOfLeadingZeros(1) != (SIZE - 1)) + throw new RuntimeException("j"); + + if (numberOfTrailingZeros(0) != SIZE) + throw new RuntimeException("k"); + if (numberOfTrailingZeros(1) != 0) + throw new RuntimeException("l"); + if (numberOfTrailingZeros(MIN_VALUE) != (SIZE - 1)) + throw new RuntimeException("m"); + + for (int i = 0; i < N; i++) { + int x = rnd.nextInt(); + if (numberOfLeadingZeros(x) != numberOfTrailingZeros(reverse(x))) + throw new RuntimeException("n: " + toHexString(x)); + } + + if (bitCount(0) != 0) + throw new RuntimeException("o"); + + for (int i = 0; i < SIZE; i++) { + int pow2 = 1 << i; + if (bitCount(pow2) != 1) + throw new RuntimeException("p: " + i); + if (bitCount(pow2 -1) != i) + throw new RuntimeException("q: " + i); + } + + for (int i = 0; i < N; i++) { + int x = rnd.nextInt(); + if (bitCount(x) != bitCount(reverse(x))) + throw new RuntimeException("r: " + toHexString(x)); + } + + for (int i = 0; i < N; i++) { + int x = rnd.nextInt(); + int dist = rnd.nextInt(); + if (bitCount(x) != bitCount(rotateRight(x, dist))) + throw new RuntimeException("s: " + toHexString(x) + + toHexString(dist)); + if (bitCount(x) != bitCount(rotateLeft(x, dist))) + throw new RuntimeException("t: " + toHexString(x) + + toHexString(dist)); + if (rotateRight(x, dist) != rotateLeft(x, -dist)) + throw new RuntimeException("u: " + toHexString(x) + + toHexString(dist)); + if (rotateRight(x, -dist) != rotateLeft(x, dist)) + throw new RuntimeException("v: " + toHexString(x) + + toHexString(dist)); + } + + if (signum(0) != 0 || signum(1) != 1 || signum(-1) != -1 + || signum(MIN_VALUE) != -1 || signum(MAX_VALUE) != 1) + throw new RuntimeException("w"); + + for (int i = 0; i < N; i++) { + int x = rnd.nextInt(); + int sign = (x < 0 ? -1 : (x == 0 ? 0 : 1)); + if (signum(x) != sign) + throw new RuntimeException("x: " + toHexString(x)); + } + + if(reverseBytes(0xaabbccdd) != 0xddccbbaa) + throw new RuntimeException("y"); + + for (int i = 0; i < N; i++) { + int x = rnd.nextInt(); + if (bitCount(x) != bitCount(reverseBytes(x))) + throw new RuntimeException("z: " + toHexString(x)); + } + } +} --- /dev/null Mon Jan 26 16:11:58 2009 +++ new/test/java/lang/Integer/Decode.java Mon Jan 26 16:11:57 2009 @@ -0,0 +1,102 @@ +/* + * Copyright 2006 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 4136371 5017980 6576055 + * @summary Test Integer.decode method + * @author madbot + * @author Joseph D. Darcy + */ + +/** + * There are six methods in java.lang.Integer which transform strings + * into an int or Integer value: + * + * public Integer(String s) + * public static Integer decode(String nm) + * public static int parseInteger(String s, int radix) + * public static int parseInteger(String s) + * public static Integer valueOf(String s, int radix) + * public static Integer valueOf(String s) + * + * The other five methods are tested elsewhere. + */ +public class Decode { + + private static void check(String val, int expected) { + int n = (Integer.decode(val)).intValue(); + if (n != expected) + throw new RuntimeException("Integer.decode failed. String:" + + val + " Result:" + n); + } + + private static void checkFailure(String val, String message) { + try { + int n = (Integer.decode(val)).intValue(); + throw new RuntimeException(message); + } catch (NumberFormatException e) { /* Okay */} + } + + public static void main(String[] args) throws Exception { + check(new String(""+Integer.MIN_VALUE), Integer.MIN_VALUE); + check(new String(""+Integer.MAX_VALUE), Integer.MAX_VALUE); + + check("10", 10); + check("0x10", 16); + check("0X10", 16); + check("010", 8); + check("#10", 16); + + check("+10", 10); + check("+0x10", 16); + check("+0X10", 16); + check("+010", 8); + check("+#10", 16); + + check("-10", -10); + check("-0x10", -16); + check("-0X10", -16); + check("-010", -8); + check("-#10", -16); + + check(Long.toString(Integer.MIN_VALUE), Integer.MIN_VALUE); + check(Long.toString(Integer.MAX_VALUE), Integer.MAX_VALUE); + + checkFailure("0x-10", "Integer.decode allows negative sign in wrong position."); + checkFailure("0x+10", "Integer.decode allows positive sign in wrong position."); + + checkFailure("+", "Raw plus sign allowed."); + checkFailure("-", "Raw minus sign allowed."); + + checkFailure(Long.toString((long)Integer.MIN_VALUE - 1L), "Out of range"); + checkFailure(Long.toString((long)Integer.MAX_VALUE + 1L), "Out of range"); + + checkFailure("", "Empty String"); + + try { + Integer.decode(null); + throw new RuntimeException("Integer.decode(null) expected to throw NPE"); + } catch (NullPointerException npe) {/* Okay */} + } +} --- /dev/null Mon Jan 26 16:12:00 2009 +++ new/test/java/lang/Integer/GetInteger.java Mon Jan 26 16:11:59 2009 @@ -0,0 +1,35 @@ +/* + * Copyright 1999 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 4252315 + * @summary test Integer.getInteger method with empty key + */ + +public class GetInteger { + public static void main(String[] args) throws Exception { + Integer.getInteger("", 1); + Integer.getInteger(null, 1); + } +} --- /dev/null Mon Jan 26 16:12:02 2009 +++ new/test/java/lang/Integer/ParsingTest.java Mon Jan 26 16:12:01 2009 @@ -0,0 +1,94 @@ +/* + * Copyright 2006-2007 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 5017980 6576055 + * @summary Test parsing methods + * @author Joseph D. Darcy + */ + + +/** + * There are six methods in java.lang.Integer which transform strings + * into an int or Integer value: + * + * public Integer(String s) + * public static Integer decode(String nm) + * public static int parseInt(String s, int radix) + * public static int parseInt(String s) + * public static Integer valueOf(String s, int radix) + * public static Integer valueOf(String s) + * + * Besides decode, all the methods and constructor call down into + * parseInt(String, int) to do the actual work. Therefore, the + * behavior of parseInt(String, int) will be tested here. + */ + +public class ParsingTest { + public static void main(String... argv) { + check("+100", +100); + check("-100", -100); + + check("+0", 0); + check("-0", 0); + check("+00000", 0); + check("-00000", 0); + + check("0", 0); + check("1", 1); + check("9", 9); + + checkFailure("\u0000"); + checkFailure("\u002f"); + checkFailure("+"); + checkFailure("-"); + checkFailure("++"); + checkFailure("+-"); + checkFailure("-+"); + checkFailure("--"); + checkFailure("++100"); + checkFailure("--100"); + checkFailure("+-6"); + checkFailure("-+6"); + checkFailure("*100"); + } + + private static void check(String val, int expected) { + int n = Integer.parseInt(val); + if (n != expected) + throw new RuntimeException("Integer.parsedInt failed. String:" + + val + " Result:" + n); + } + + private static void checkFailure(String val) { + int n = 0; + try { + n = Integer.parseInt(val); + System.err.println("parseInt(" + val + ") incorrectly returned " + n); + throw new RuntimeException(); + } catch (NumberFormatException nfe) { + ; // Expected + } + } +} --- /dev/null Mon Jan 26 16:12:04 2009 +++ new/test/java/lang/Long/BitTwiddle.java Mon Jan 26 16:12:03 2009 @@ -0,0 +1,137 @@ +/* + * Copyright 2003 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 4495754 + * @summary Basic test for long bit twiddling + * @author Josh Bloch + * + * @compile -source 1.5 BitTwiddle.java + * @run main BitTwiddle + */ + +import java.util.Random; +import static java.lang.Long.*; + +public class BitTwiddle { + private static final int N = 1000; // # of repetitions per test + + public static void main(String args[]) { + Random rnd = new Random(); + + if (highestOneBit(0) != 0) + throw new RuntimeException("a"); + if (highestOneBit(-1) != MIN_VALUE) + throw new RuntimeException("b"); + if (highestOneBit(1) != 1) + throw new RuntimeException("c"); + + if (lowestOneBit(0) != 0) + throw new RuntimeException("d"); + if (lowestOneBit(-1) != 1) + throw new RuntimeException("e"); + if (lowestOneBit(MIN_VALUE) != MIN_VALUE) + throw new RuntimeException("f"); + + for (int i = 0; i < N; i++) { + long x = rnd.nextLong(); + if (highestOneBit(x) != reverse(lowestOneBit(reverse(x)))) + throw new RuntimeException("g: " + toHexString(x)); + } + + if (numberOfLeadingZeros(0) != SIZE) + throw new RuntimeException("h"); + if (numberOfLeadingZeros(-1) != 0) + throw new RuntimeException("i"); + if (numberOfLeadingZeros(1) != (SIZE - 1)) + throw new RuntimeException("j"); + + if (numberOfTrailingZeros(0) != SIZE) + throw new RuntimeException("k"); + if (numberOfTrailingZeros(1) != 0) + throw new RuntimeException("l"); + if (numberOfTrailingZeros(MIN_VALUE) != (SIZE - 1)) + throw new RuntimeException("m"); + + for (int i = 0; i < N; i++) { + long x = rnd.nextLong(); + if (numberOfLeadingZeros(x) != numberOfTrailingZeros(reverse(x))) + throw new RuntimeException("n: " + toHexString(x)); + } + + if (bitCount(0) != 0) + throw new RuntimeException("o"); + + for (int i = 0; i < SIZE; i++) { + long pow2 = 1L << i; + if (bitCount(pow2) != 1) + throw new RuntimeException("p: " + i); + if (bitCount(pow2 -1) != i) + throw new RuntimeException("q: " + i); + } + + for (int i = 0; i < N; i++) { + long x = rnd.nextLong(); + if (bitCount(x) != bitCount(reverse(x))) + throw new RuntimeException("r: " + toHexString(x)); + } + + for (int i = 0; i < N; i++) { + long x = rnd.nextLong(); + int dist = rnd.nextInt(); + if (bitCount(x) != bitCount(rotateRight(x, dist))) + throw new RuntimeException("s: " + toHexString(x) + + toHexString(dist)); + if (bitCount(x) != bitCount(rotateLeft(x, dist))) + throw new RuntimeException("t: " + toHexString(x) + + toHexString(dist)); + if (rotateRight(x, dist) != rotateLeft(x, -dist)) + throw new RuntimeException("u: " + toHexString(x) + + toHexString(dist)); + if (rotateRight(x, -dist) != rotateLeft(x, dist)) + throw new RuntimeException("v: " + toHexString(x) + + toHexString(dist)); + } + + if (signum(0) != 0 || signum(1) != 1 || signum(-1) != -1 + || signum(MIN_VALUE) != -1 || signum(MAX_VALUE) != 1) + throw new RuntimeException("w"); + + for (int i = 0; i < N; i++) { + long x = rnd.nextLong(); + int sign = (x < 0 ? -1 : (x == 0 ? 0 : 1)); + if (signum(x) != sign) + throw new RuntimeException("x: " + toHexString(x)); + } + + if(reverseBytes(0xaabbccdd11223344L) != 0x44332211ddccbbaaL) + throw new RuntimeException("y"); + + for (int i = 0; i < N; i++) { + long x = rnd.nextLong(); + if (bitCount(x) != bitCount(reverseBytes(x))) + throw new RuntimeException("z: " + toHexString(x)); + } + } +} --- /dev/null Mon Jan 26 16:12:07 2009 +++ new/test/java/lang/Long/Decode.java Mon Jan 26 16:12:06 2009 @@ -0,0 +1,106 @@ +/* + * Copyright 1998-2006 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 4136371 5017980 6576055 + * @summary Test Long.decode method + * @author madbot + * @author Joseph D. Darcy + */ + +import java.math.BigInteger; + +/** + * There are six methods in java.lang.Integer which transform strings + * into a long or Long value: + * + * public Long(String s) + * public static Long decode(String nm) + * public static long parseLong(String s, int radix) + * public static long parseLong(String s) + * public static Long valueOf(String s, int radix) + * public static Long valueOf(String s) + * + * The other five methods are tested elsewhere. + */ +public class Decode { + + private static void check(String val, long expected) { + long n = (Long.decode(val)).longValue(); + if (n != expected) + throw new RuntimeException("Long.decode failed. String:" + + val + " Result:" + n); + } + + private static void checkFailure(String val, String message) { + try { + long n = (Long.decode(val)).longValue(); + throw new RuntimeException(message); + } catch (NumberFormatException e) { /* Okay */} + } + + public static void main(String[] args) throws Exception { + check(new String(""+Long.MIN_VALUE), Long.MIN_VALUE); + check(new String(""+Long.MAX_VALUE), Long.MAX_VALUE); + + check("10", 10L); + check("0x10", 16L); + check("0X10", 16L); + check("010", 8L); + check("#10", 16L); + + check("+10", 10L); + check("+0x10", 16L); + check("+0X10", 16L); + check("+010", 8L); + check("+#10", 16L); + + check("-10", -10L); + check("-0x10", -16L); + check("-0X10", -16L); + check("-010", -8L); + check("-#10", -16L); + + check(Long.toString(Long.MIN_VALUE), Long.MIN_VALUE); + check(Long.toString(Long.MAX_VALUE), Long.MAX_VALUE); + + checkFailure("0x-10", "Long.decode allows negative sign in wrong position."); + checkFailure("0x+10", "Long.decode allows positive sign in wrong position."); + + checkFailure("+", "Raw plus sign allowed."); + checkFailure("-", "Raw minus sign allowed."); + + checkFailure(BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE).toString(), + "Out of range"); + checkFailure(BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE).toString(), + "Out of range"); + + checkFailure("", "Empty String"); + + try { + Long.decode(null); + throw new RuntimeException("Long.decode(null) expected to throw NPE"); + } catch (NullPointerException npe) {/* Okay */} + } +} --- /dev/null Mon Jan 26 16:12:09 2009 +++ new/test/java/lang/Long/GetLong.java Mon Jan 26 16:12:08 2009 @@ -0,0 +1,35 @@ +/* + * Copyright 1999 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 4252322 + * @summary test Long.getLong method with empty key + */ + +public class GetLong { + public static void main(String[] args) throws Exception { + Long.getLong("", 1); + Long.getLong(null, 1); + } +} --- /dev/null Mon Jan 26 16:12:11 2009 +++ new/test/java/lang/Long/ParsingTest.java Mon Jan 26 16:12:10 2009 @@ -0,0 +1,94 @@ +/* + * Copyright 2006-2007 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 5017980 6576055 + * @summary Test parsing methods + * @author Joseph D. Darcy + */ + + +/** + * There are six methods in java.lang.Long which transform strings + * into a long or Long value: + * + * public Long(String s) + * public static Long decode(String nm) + * public static long parseLong(String s, int radix) + * public static long parseLong(String s) + * public static Long valueOf(String s, int radix) + * public static Long valueOf(String s) + * + * Besides decode, all the methods and constructor call down into + * parseLong(String, int) to do the actual work. Therefore, the + * behavior of parseLong(String, int) will be tested here. + */ + +public class ParsingTest { + public static void main(String... argv) { + check("+100", +100L); + check("-100", -100L); + + check("+0", 0L); + check("-0", 0L); + check("+00000", 0L); + check("-00000", 0L); + + check("0", 0L); + check("1", 1L); + check("9", 9L); + + checkFailure("\u0000"); + checkFailure("\u002f"); + checkFailure("+"); + checkFailure("-"); + checkFailure("++"); + checkFailure("+-"); + checkFailure("-+"); + checkFailure("--"); + checkFailure("++100"); + checkFailure("--100"); + checkFailure("+-6"); + checkFailure("-+6"); + checkFailure("*100"); + } + + private static void check(String val, long expected) { + long n = Long.parseLong(val); + if (n != expected) + throw new RuntimeException("Long.parsedLong failed. String:" + + val + " Result:" + n); + } + + private static void checkFailure(String val) { + long n = 0L; + try { + n = Long.parseLong(val); + System.err.println("parseLong(" + val + ") incorrectly returned " + n); + throw new RuntimeException(); + } catch (NumberFormatException nfe) { + ; // Expected + } + } +} --- /dev/null Mon Jan 26 16:12:13 2009 +++ new/test/java/lang/Math/AbsPositiveZero.java Mon Jan 26 16:12:12 2009 @@ -0,0 +1,73 @@ +/* + * Copyright 1998 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 4096278 + @summary Math.abs(+0.0) wrong + @author Anand Palaniswamy + */ +public class AbsPositiveZero { + private static boolean isPositiveZero(float f) { + return Float.floatToIntBits(f) == Float.floatToIntBits(0.0f); + } + + private static boolean isPositiveZero(double d) { + return Double.doubleToLongBits(d) == Double.doubleToLongBits(0.0d); + } + + public static void main(String[] args) throws Exception { + if (!isPositiveZero(Math.abs(-0.0d))) { + throw new Exception("abs(-0.0d) failed"); + } + if (!isPositiveZero(Math.abs(+0.0d))) { + throw new Exception("abs(+0.0d) failed"); + } + if (Math.abs(Double.POSITIVE_INFINITY) != Double.POSITIVE_INFINITY) { + throw new Exception("abs(+Inf) failed"); + } + if (Math.abs(Double.NEGATIVE_INFINITY) != Double.POSITIVE_INFINITY) { + throw new Exception("abs(-Inf) failed"); + } + double dnanval = Math.abs(Double.NaN); + if (dnanval == dnanval) { + throw new Exception("abs(NaN) failed"); + } + + if (!isPositiveZero(Math.abs(-0.0f))) { + throw new Exception("abs(-0.0f) failed"); + } + if (!isPositiveZero(Math.abs(+0.0f))) { + throw new Exception("abs(+0.0f) failed"); + } + if (Math.abs(Float.POSITIVE_INFINITY) != Float.POSITIVE_INFINITY) { + throw new Exception("abs(+Inf) failed"); + } + if (Math.abs(Float.NEGATIVE_INFINITY) != Float.POSITIVE_INFINITY) { + throw new Exception("abs(-Inf) failed"); + } + float fnanval = Math.abs(Float.NaN); + if (fnanval == fnanval) { + throw new Exception("abs(NaN) failed"); + } + } +} --- /dev/null Mon Jan 26 16:12:16 2009 +++ new/test/java/lang/Math/Atan2Tests.java Mon Jan 26 16:12:15 2009 @@ -0,0 +1,71 @@ +/* + * 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 4984407 + * @summary Tests for {Math, StrictMath}.atan2 + * @compile -source 1.5 Atan2Tests.java + * @run main Atan2Tests + * @author Joseph D. Darcy + */ + +public class Atan2Tests { + private Atan2Tests(){} + + static int testAtan2Case(double input1, double input2, double expected) { + int failures = 0; + failures += Tests.test("StrictMath.atan2(double, double)", input1, input2, + StrictMath.atan2(input1, input2), expected); + failures += Tests.test("Math.atan2(double, double)", input1, input2, + Math.atan2(input1, input2), expected); + + return failures; + } + + static int testAtan2() { + int failures = 0; + + double [][] testCases = { + {-3.0, Double.POSITIVE_INFINITY, -0.0}, + }; + + for (double[] testCase : testCases) { + failures+=testAtan2Case(testCase[0], testCase[1], testCase[2]); + } + + return failures; + } + + public static void main(String [] argv) { + int failures = 0; + + failures += testAtan2(); + + if (failures > 0) { + System.err.println("Testing atan2 incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:18 2009 +++ new/test/java/lang/Math/CubeRootTests.java Mon Jan 26 16:12:17 2009 @@ -0,0 +1,336 @@ +/* + * Copyright 2003 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 4347132 4939441 + * @summary Tests for {Math, StrictMath}.cbrt + * @author Joseph D. Darcy + */ + +import sun.misc.FpUtils; +import sun.misc.DoubleConsts; + +public class CubeRootTests { + private CubeRootTests(){} + + static final double infinityD = Double.POSITIVE_INFINITY; + static final double NaNd = Double.NaN; + + // Initialize shared random number generator + static java.util.Random rand = new java.util.Random(); + + static int testCubeRootCase(double input, double expected) { + int failures=0; + + double minus_input = -input; + double minus_expected = -expected; + + failures+=Tests.test("Math.cbrt(double)", input, + Math.cbrt(input), expected); + failures+=Tests.test("Math.cbrt(double)", minus_input, + Math.cbrt(minus_input), minus_expected); + failures+=Tests.test("StrictMath.cbrt(double)", input, + StrictMath.cbrt(input), expected); + failures+=Tests.test("StrictMath.cbrt(double)", minus_input, + StrictMath.cbrt(minus_input), minus_expected); + + return failures; + } + + static int testCubeRoot() { + int failures = 0; + double [][] testCases = { + {NaNd, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, + {Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY}, + {Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY}, + {+0.0, +0.0}, + {-0.0, -0.0}, + {+1.0, +1.0}, + {-1.0, -1.0}, + {+8.0, +2.0}, + {-8.0, -2.0} + }; + + for(int i = 0; i < testCases.length; i++) { + failures += testCubeRootCase(testCases[i][0], + testCases[i][1]); + } + + // Test integer perfect cubes less than 2^53. + for(int i = 0; i <= 208063; i++) { + double d = i; + failures += testCubeRootCase(d*d*d, (double)i); + } + + // Test cbrt(2^(3n)) = 2^n. + for(int i = 18; i <= DoubleConsts.MAX_EXPONENT/3; i++) { + failures += testCubeRootCase(FpUtils.scalb(1.0, 3*i), + FpUtils.scalb(1.0, i) ); + } + + // Test cbrt(2^(-3n)) = 2^-n. + for(int i = -1; i >= FpUtils.ilogb(Double.MIN_VALUE)/3; i--) { + failures += testCubeRootCase(FpUtils.scalb(1.0, 3*i), + FpUtils.scalb(1.0, i) ); + } + + // Test random perfect cubes. Create double values with + // modest exponents but only have at most the 17 most + // significant bits in the significand set; 17*3 = 51, which + // is less than the number of bits in a double's significand. + long exponentBits1 = + Double.doubleToLongBits(FpUtils.scalb(1.0, 55)) & + DoubleConsts.EXP_BIT_MASK; + long exponentBits2= + Double.doubleToLongBits(FpUtils.scalb(1.0, -55)) & + DoubleConsts.EXP_BIT_MASK; + for(int i = 0; i < 100; i++) { + // Take 16 bits since the 17th bit is implicit in the + // exponent + double input1 = + Double.longBitsToDouble(exponentBits1 | + // Significand bits + ((long) (rand.nextInt() & 0xFFFF))<< + (DoubleConsts.SIGNIFICAND_WIDTH-1-16)); + failures += testCubeRootCase(input1*input1*input1, input1); + + double input2 = + Double.longBitsToDouble(exponentBits2 | + // Significand bits + ((long) (rand.nextInt() & 0xFFFF))<< + (DoubleConsts.SIGNIFICAND_WIDTH-1-16)); + failures += testCubeRootCase(input2*input2*input2, input2); + } + + // Directly test quality of implementation properties of cbrt + // for values that aren't perfect cubes. Verify returned + // result meets the 1 ulp test. That is, we want to verify + // that for positive x > 1, + // y = cbrt(x), + // + // if (err1=x - y^3 ) < 0, abs((y_pp^3 -x )) < err1 + // if (err1=x - y^3 ) > 0, abs((y_mm^3 -x )) < err1 + // + // where y_mm and y_pp are the next smaller and next larger + // floating-point value to y. In other words, if y^3 is too + // big, making y larger does not improve the result; likewise, + // if y^3 is too small, making y smaller does not improve the + // result. + // + // ...-----|--?--|--?--|-----... Where is the true result? + // y_mm y y_pp + // + // The returned value y should be one of the floating-point + // values braketing the true result. However, given y, a + // priori we don't know if the true result falls in [y_mm, y] + // or [y, y_pp]. The above test looks at the error in x-y^3 + // to determine which region the true result is in; e.g. if + // y^3 is smaller than x, the true result should be in [y, + // y_pp]. Therefore, it would be an error for y_mm to be a + // closer approximation to x^(1/3). In this case, it is + // permissible, although not ideal, for y_pp^3 to be a closer + // approximation to x^(1/3) than y^3. + // + // We will use pow(y,3) to compute y^3. Although pow is not + // correctly rounded, StrictMath.pow should have at most 1 ulp + // error. For y > 1, pow(y_mm,3) and pow(y_pp,3) will differ + // from pow(y,3) by more than one ulp so the comparision of + // errors should still be valid. + + for(int i = 0; i < 1000; i++) { + double d = 1.0 + rand.nextDouble(); + double err, err_adjacent; + + double y1 = Math.cbrt(d); + double y2 = StrictMath.cbrt(d); + + err = d - StrictMath.pow(y1, 3); + if (err != 0.0) { + if(FpUtils.isNaN(err)) { + failures++; + System.err.println("Encountered unexpected NaN value: d = " + d + + "\tcbrt(d) = " + y1); + } else { + if (err < 0.0) { + err_adjacent = StrictMath.pow(FpUtils.nextUp(y1), 3) - d; + } + else { // (err > 0.0) + err_adjacent = StrictMath.pow(FpUtils.nextAfter(y1,0.0), 3) - d; + } + + if (Math.abs(err) > Math.abs(err_adjacent)) { + failures++; + System.err.println("For Math.cbrt(" + d + "), returned result " + + y1 + "is not as good as adjacent value."); + } + } + } + + + err = d - StrictMath.pow(y2, 3); + if (err != 0.0) { + if(FpUtils.isNaN(err)) { + failures++; + System.err.println("Encountered unexpected NaN value: d = " + d + + "\tcbrt(d) = " + y2); + } else { + if (err < 0.0) { + err_adjacent = StrictMath.pow(FpUtils.nextUp(y2), 3) - d; + } + else { // (err > 0.0) + err_adjacent = StrictMath.pow(FpUtils.nextAfter(y2,0.0), 3) - d; + } + + if (Math.abs(err) > Math.abs(err_adjacent)) { + failures++; + System.err.println("For StrictMath.cbrt(" + d + "), returned result " + + y2 + "is not as good as adjacent value."); + } + } + } + + + } + + // Test monotonicity properites near perfect cubes; test two + // numbers before and two numbers after; i.e. for + // + // pcNeighbors[] = + // {nextDown(nextDown(pc)), + // nextDown(pc), + // pc, + // nextUp(pc), + // nextUp(nextUp(pc))} + // + // test that cbrt(pcNeighbors[i]) <= cbrt(pcNeighbors[i+1]) + { + + double pcNeighbors[] = new double[5]; + double pcNeighborsCbrt[] = new double[5]; + double pcNeighborsStrictCbrt[] = new double[5]; + + // Test near cbrt(2^(3n)) = 2^n. + for(int i = 18; i <= DoubleConsts.MAX_EXPONENT/3; i++) { + double pc = FpUtils.scalb(1.0, 3*i); + + pcNeighbors[2] = pc; + pcNeighbors[1] = FpUtils.nextDown(pc); + pcNeighbors[0] = FpUtils.nextDown(pcNeighbors[1]); + pcNeighbors[3] = FpUtils.nextUp(pc); + pcNeighbors[4] = FpUtils.nextUp(pcNeighbors[3]); + + for(int j = 0; j < pcNeighbors.length; j++) { + pcNeighborsCbrt[j] = Math.cbrt(pcNeighbors[j]); + pcNeighborsStrictCbrt[j] = StrictMath.cbrt(pcNeighbors[j]); + } + + for(int j = 0; j < pcNeighborsCbrt.length-1; j++) { + if(pcNeighborsCbrt[j] > pcNeighborsCbrt[j+1] ) { + failures++; + System.err.println("Monotonicity failure for Math.cbrt on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsCbrt[j] + " and " + + pcNeighborsCbrt[j+1] ); + } + + if(pcNeighborsStrictCbrt[j] > pcNeighborsStrictCbrt[j+1] ) { + failures++; + System.err.println("Monotonicity failure for StrictMath.cbrt on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsStrictCbrt[j] + " and " + + pcNeighborsStrictCbrt[j+1] ); + } + + + } + + } + + // Test near cbrt(2^(-3n)) = 2^-n. + for(int i = -1; i >= FpUtils.ilogb(Double.MIN_VALUE)/3; i--) { + double pc = FpUtils.scalb(1.0, 3*i); + + pcNeighbors[2] = pc; + pcNeighbors[1] = FpUtils.nextDown(pc); + pcNeighbors[0] = FpUtils.nextDown(pcNeighbors[1]); + pcNeighbors[3] = FpUtils.nextUp(pc); + pcNeighbors[4] = FpUtils.nextUp(pcNeighbors[3]); + + for(int j = 0; j < pcNeighbors.length; j++) { + pcNeighborsCbrt[j] = Math.cbrt(pcNeighbors[j]); + pcNeighborsStrictCbrt[j] = StrictMath.cbrt(pcNeighbors[j]); + } + + for(int j = 0; j < pcNeighborsCbrt.length-1; j++) { + if(pcNeighborsCbrt[j] > pcNeighborsCbrt[j+1] ) { + failures++; + System.err.println("Monotonicity failure for Math.cbrt on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsCbrt[j] + " and " + + pcNeighborsCbrt[j+1] ); + } + + if(pcNeighborsStrictCbrt[j] > pcNeighborsStrictCbrt[j+1] ) { + failures++; + System.err.println("Monotonicity failure for StrictMath.cbrt on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsStrictCbrt[j] + " and " + + pcNeighborsStrictCbrt[j+1] ); + } + + + } + } + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += testCubeRoot(); + + if (failures > 0) { + System.err.println("Testing cbrt incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } + +} --- /dev/null Mon Jan 26 16:12:20 2009 +++ new/test/java/lang/Math/Expm1Tests.java Mon Jan 26 16:12:19 2009 @@ -0,0 +1,231 @@ +/* + * Copyright 2003 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 4851638 4900189 4939441 + * @summary Tests for {Math, StrictMath}.expm1 + * @author Joseph D. Darcy + */ + +import sun.misc.DoubleConsts; +import sun.misc.FpUtils; + +/* + * The Taylor expansion of expxm1(x) = exp(x) -1 is + * + * 1 + x/1! + x^2/2! + x^3/3| + ... -1 = + * + * x + x^2/2! + x^3/3 + ... + * + * Therefore, for small values of x, expxm1 ~= x. + * + * For large values of x, expxm1(x) ~= exp(x) + * + * For large negative x, expxm1(x) ~= -1. + */ + +public class Expm1Tests { + + private Expm1Tests(){} + + static final double infinityD = Double.POSITIVE_INFINITY; + static final double NaNd = Double.NaN; + + static int testExpm1() { + int failures = 0; + + double [][] testCases = { + {Double.NaN, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, + {infinityD, infinityD}, + {-infinityD, -1.0}, + {-0.0, -0.0}, + {+0.0, +0.0}, + }; + + // Test special cases + for(int i = 0; i < testCases.length; i++) { + failures += testExpm1CaseWithUlpDiff(testCases[i][0], + testCases[i][1], 0, null); + } + + + // For |x| < 2^-54 expm1(x) ~= x + for(int i = DoubleConsts.MIN_SUB_EXPONENT; i <= -54; i++) { + double d = FpUtils.scalb(2, i); + failures += testExpm1Case(d, d); + failures += testExpm1Case(-d, -d); + } + + + // For values of y where exp(y) > 2^54, expm1(x) ~= exp(x). + // The least such y is ln(2^54) ~= 37.42994775023705; exp(x) + // overflows for x > ~= 709.8 + + // Use a 2-ulp error threshold to account for errors in the + // exp implementation; the increments of d in the loop will be + // exact. + for(double d = 37.5; d <= 709.5; d += 1.0) { + failures += testExpm1CaseWithUlpDiff(d, StrictMath.exp(d), 2, null); + } + + // For x > 710, expm1(x) should be infinity + for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) { + double d = FpUtils.scalb(2, i); + failures += testExpm1Case(d, infinityD); + } + + // By monotonicity, once the limit is reached, the + // implemenation should return the limit for all smaller + // values. + boolean reachedLimit [] = {false, false}; + + // Once exp(y) < 0.5 * ulp(1), expm1(y) ~= -1.0; + // The greatest such y is ln(2^-53) ~= -36.7368005696771. + for(double d = -36.75; d >= -127.75; d -= 1.0) { + failures += testExpm1CaseWithUlpDiff(d, -1.0, 1, + reachedLimit); + } + + for(int i = 7; i <= DoubleConsts.MAX_EXPONENT; i++) { + double d = -FpUtils.scalb(2, i); + failures += testExpm1CaseWithUlpDiff(d, -1.0, 1, reachedLimit); + } + + // Test for monotonicity failures near multiples of log(2). + // Test two numbers before and two numbers after each chosen + // value; i.e. + // + // pcNeighbors[] = + // {nextDown(nextDown(pc)), + // nextDown(pc), + // pc, + // nextUp(pc), + // nextUp(nextUp(pc))} + // + // and we test that expm1(pcNeighbors[i]) <= expm1(pcNeighbors[i+1]) + { + double pcNeighbors[] = new double[5]; + double pcNeighborsExpm1[] = new double[5]; + double pcNeighborsStrictExpm1[] = new double[5]; + + for(int i = -50; i <= 50; i++) { + double pc = StrictMath.log(2)*i; + + pcNeighbors[2] = pc; + pcNeighbors[1] = FpUtils.nextDown(pc); + pcNeighbors[0] = FpUtils.nextDown(pcNeighbors[1]); + pcNeighbors[3] = FpUtils.nextUp(pc); + pcNeighbors[4] = FpUtils.nextUp(pcNeighbors[3]); + + for(int j = 0; j < pcNeighbors.length; j++) { + pcNeighborsExpm1[j] = Math.expm1(pcNeighbors[j]); + pcNeighborsStrictExpm1[j] = StrictMath.expm1(pcNeighbors[j]); + } + + for(int j = 0; j < pcNeighborsExpm1.length-1; j++) { + if(pcNeighborsExpm1[j] > pcNeighborsExpm1[j+1] ) { + failures++; + System.err.println("Monotonicity failure for Math.expm1 on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsExpm1[j] + " and " + + pcNeighborsExpm1[j+1] ); + } + + if(pcNeighborsStrictExpm1[j] > pcNeighborsStrictExpm1[j+1] ) { + failures++; + System.err.println("Monotonicity failure for StrictMath.expm1 on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsStrictExpm1[j] + " and " + + pcNeighborsStrictExpm1[j+1] ); + } + + + } + + } + } + + return failures; + } + + public static int testExpm1Case(double input, + double expected) { + return testExpm1CaseWithUlpDiff(input, expected, 1, null); + } + + public static int testExpm1CaseWithUlpDiff(double input, + double expected, + double ulps, + boolean [] reachedLimit) { + int failures = 0; + double mathUlps = ulps, strictUlps = ulps; + double mathOutput; + double strictOutput; + + if (reachedLimit != null) { + if (reachedLimit[0]) + mathUlps = 0; + + if (reachedLimit[1]) + strictUlps = 0; + } + + failures += Tests.testUlpDiffWithLowerBound("Math.expm1(double)", + input, mathOutput=Math.expm1(input), + expected, mathUlps, -1.0); + failures += Tests.testUlpDiffWithLowerBound("StrictMath.expm1(double)", + input, strictOutput=StrictMath.expm1(input), + expected, strictUlps, -1.0); + if (reachedLimit != null) { + reachedLimit[0] |= (mathOutput == -1.0); + reachedLimit[1] |= (strictOutput == -1.0); + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += testExpm1(); + + if (failures > 0) { + System.err.println("Testing expm1 incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:22 2009 +++ new/test/java/lang/Math/HyperbolicTests.java Mon Jan 26 16:12:21 2009 @@ -0,0 +1,1065 @@ +/* + * Copyright 2003 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 4851625 4900189 4939441 + * @summary Tests for {Math, StrictMath}.{sinh, cosh, tanh} + * @author Joseph D. Darcy + */ + +import sun.misc.DoubleConsts; +import sun.misc.FpUtils; + +public class HyperbolicTests { + private HyperbolicTests(){} + + static final double NaNd = Double.NaN; + + /** + * Test accuracy of {Math, StrictMath}.sinh. The specified + * accuracy is 2.5 ulps. + * + * The defintion of sinh(x) is + * + * (e^x - e^(-x))/2 + * + * The series expansion of sinh(x) = + * + * x + x^3/3! + x^5/5! + x^7/7! +... + * + * Therefore, + * + * 1. For large values of x sinh(x) ~= signum(x)*exp(|x|)/2 + * + * 2. For small values of x, sinh(x) ~= x. + * + * Additionally, sinh is an odd function; sinh(-x) = -sinh(x). + * + */ + static int testSinh() { + int failures = 0; + /* + * Array elements below generated using a quad sinh + * implementation. Rounded to a double, the quad result + * *should* be correctly rounded, unless we are quite unlucky. + * Assuming the quad value is a correctly rounded double, the + * allowed error is 3.0 ulps instead of 2.5 since the quad + * value rounded to double can have its own 1/2 ulp error. + */ + double [][] testCases = { + // x sinh(x) + {0.0625, 0.06254069805219182172183988501029229}, + {0.1250, 0.12532577524111545698205754229137154}, + {0.1875, 0.18860056562029018382047025055167585}, + {0.2500, 0.25261231680816830791412515054205787}, + {0.3125, 0.31761115611357728583959867611490292}, + {0.3750, 0.38385106791361456875429567642050245}, + {0.4375, 0.45159088610312053032509815226723017}, + {0.5000, 0.52109530549374736162242562641149155}, + {0.5625, 0.59263591611468777373870867338492247}, + {0.6250, 0.66649226445661608227260655608302908}, + {0.6875, 0.74295294580567543571442036910465007}, + {0.7500, 0.82231673193582998070366163444691386}, + {0.8125, 0.90489373856606433650504536421491368}, + {0.8750, 0.99100663714429475605317427568995231}, + {0.9375, 1.08099191569306394011007867453992548}, + {1.0000, 1.17520119364380145688238185059560082}, + {1.0625, 1.27400259579739321279181130344911907}, + {1.1250, 1.37778219077984075760379987065228373}, + {1.1875, 1.48694549961380717221109202361777593}, + {1.2500, 1.60191908030082563790283030151221415}, + {1.3125, 1.72315219460596010219069206464391528}, + {1.3750, 1.85111856355791532419998548438506416}, + {1.4375, 1.98631821852425112898943304217629457}, + {1.5000, 2.12927945509481749683438749467763195}, + {1.5625, 2.28056089740825247058075476705718764}, + {1.6250, 2.44075368098794353221372986997161132}, + {1.6875, 2.61048376261693140366028569794027603}, + {1.7500, 2.79041436627764265509289122308816092}, + {1.8125, 2.98124857471401377943765253243875520}, + {1.8750, 3.18373207674259205101326780071803724}, + {1.9375, 3.39865608104779099764440244167531810}, + {2.0000, 3.62686040784701876766821398280126192}, + {2.0625, 3.86923677050642806693938384073620450}, + {2.1250, 4.12673225993027252260441410537905269}, + {2.1875, 4.40035304533919660406976249684469164}, + {2.2500, 4.69116830589833069188357567763552003}, + {2.3125, 5.00031440855811351554075363240262157}, + {2.3750, 5.32899934843284576394645856548481489}, + {2.4375, 5.67850746906785056212578751630266858}, + {2.5000, 6.05020448103978732145032363835040319}, + {2.5625, 6.44554279850040875063706020260185553}, + {2.6250, 6.86606721451642172826145238779845813}, + {2.6875, 7.31342093738196587585692115636603571}, + {2.7500, 7.78935201149073201875513401029935330}, + {2.8125, 8.29572014785741787167717932988491961}, + {2.8750, 8.83450399097893197351853322827892144}, + {2.9375, 9.40780885043076394429977972921690859}, + {3.0000, 10.01787492740990189897459361946582867}, + {3.0625, 10.66708606836969224165124519209968368}, + {3.1250, 11.35797907995166028304704128775698426}, + {3.1875, 12.09325364161259019614431093344260209}, + {3.2500, 12.87578285468067003959660391705481220}, + {3.3125, 13.70862446906136798063935858393686525}, + {3.3750, 14.59503283146163690015482636921657975}, + {3.4375, 15.53847160182039311025096666980558478}, + {3.5000, 16.54262728763499762495673152901249743}, + {3.5625, 17.61142364906941482858466494889121694}, + {3.6250, 18.74903703113232171399165788088277979}, + {3.6875, 19.95991268283598684128844120984214675}, + {3.7500, 21.24878212710338697364101071825171163}, + {3.8125, 22.62068164929685091969259499078125023}, + {3.8750, 24.08097197661255803883403419733891573}, + {3.9375, 25.63535922523855307175060244757748997}, + {4.0000, 27.28991719712775244890827159079382096}, + {4.0625, 29.05111111351106713777825462100160185}, + {4.1250, 30.92582287788986031725487699744107092}, + {4.1875, 32.92137796722343190618721270937061472}, + {4.2500, 35.04557405638942942322929652461901154}, + {4.3125, 37.30671148776788628118833357170042385}, + {4.3750, 39.71362570500944929025069048612806024}, + {4.4375, 42.27572177772344954814418332587050658}, + {4.5000, 45.00301115199178562180965680564371424}, + {4.5625, 47.90615077031205065685078058248081891}, + {4.6250, 50.99648471383193131253995134526177467}, + {4.6875, 54.28608852959281437757368957713936555}, + {4.7500, 57.78781641599226874961859781628591635}, + {4.8125, 61.51535145084362283008545918273109379}, + {4.8750, 65.48325905829987165560146562921543361}, + {4.9375, 69.70704392356508084094318094283346381}, + {5.0000, 74.20321057778875897700947199606456364}, + {5.0625, 78.98932788987998983462810080907521151}, + {5.1250, 84.08409771724448958901392613147384951}, + {5.1875, 89.50742798369883598816307922895346849}, + {5.2500, 95.28051047011540739630959111303975956}, + {5.3125, 101.42590362176666730633859252034238987}, + {5.3750, 107.96762069594029162704530843962700133}, + {5.4375, 114.93122359426386042048760580590182604}, + {5.5000, 122.34392274639096192409774240457730721}, + {5.5625, 130.23468343534638291488502321709913206}, + {5.6250, 138.63433897999898233879574111119546728}, + {5.6875, 147.57571121692522056519568264304815790}, + {5.7500, 157.09373875244884423880085377625986165}, + {5.8125, 167.22561348600435888568183143777868662}, + {5.8750, 178.01092593829229887752609866133883987}, + {5.9375, 189.49181995209921964640216682906501778}, + {6.0000, 201.71315737027922812498206768797872263}, + {6.0625, 214.72269333437984291483666459592578915}, + {6.1250, 228.57126288889537420461281285729970085}, + {6.1875, 243.31297962030799867970551767086092471}, + {6.2500, 259.00544710710289911522315435345489966}, + {6.3125, 275.70998400700299790136562219920451185}, + {6.3750, 293.49186366095654566861661249898332253}, + {6.4375, 312.42056915013535342987623229485223434}, + {6.5000, 332.57006480258443156075705566965111346}, + {6.5625, 354.01908521044116928437570109827956007}, + {6.6250, 376.85144288706511933454985188849781703}, + {6.6875, 401.15635576625530823119100750634165252}, + {6.7500, 427.02879582326538080306830640235938517}, + {6.8125, 454.56986017986077163530945733572724452}, + {6.8750, 483.88716614351897894746751705315210621}, + {6.9375, 515.09527172439720070161654727225752288}, + {7.0000, 548.31612327324652237375611757601851598}, + {7.0625, 583.67953198942753384680988096024373270}, + {7.1250, 621.32368116099280160364794462812762880}, + {7.1875, 661.39566611888784148449430491465857519}, + {7.2500, 704.05206901515336623551137120663358760}, + {7.3125, 749.45957067108712382864538206200700256}, + {7.3750, 797.79560188617531521347351754559776282}, + {7.4375, 849.24903675279739482863565789325699416}, + {7.5000, 904.02093068584652953510919038935849651}, + {7.5625, 962.32530605113249628368993221570636328}, + {7.6250, 1024.38998846242707559349318193113614698}, + {7.6875, 1090.45749701500081956792547346904792325}, + {7.7500, 1160.78599193425808533255719118417856088}, + {7.8125, 1235.65028334242796895820912936318532502}, + {7.8750, 1315.34290508508890654067255740428824014}, + {7.9375, 1400.17525781352742299995139486063802583}, + {8.0000, 1490.47882578955018611587663903188144796}, + {8.0625, 1586.60647216744061169450001100145859236}, + {8.1250, 1688.93381781440241350635231605477507900}, + {8.1875, 1797.86070905726094477721128358866360644}, + {8.2500, 1913.81278009067446281883262689250118009}, + {8.3125, 2037.24311615199935553277163192983440062}, + {8.3750, 2168.63402396170125867037749369723761636}, + {8.4375, 2308.49891634734644432370720900969004306}, + {8.5000, 2457.38431841538268239359965370719928775}, + {8.5625, 2615.87200310986940554256648824234335262}, + {8.6250, 2784.58126450289932429469130598902487336}, + {8.6875, 2964.17133769964321637973459949999057146}, + {8.7500, 3155.34397481384944060352507473513108710}, + {8.8125, 3358.84618707947841898217318996045550438}, + {8.8750, 3575.47316381333288862617411467285480067}, + {8.9375, 3806.07137963459383403903729660349293583}, + {9.0000, 4051.54190208278996051522359589803425598}, + {9.0625, 4312.84391255878980330955246931164633615}, + {9.1250, 4590.99845434696991399363282718106006883}, + {9.1875, 4887.09242236403719571363798584676797558}, + {9.2500, 5202.28281022453561319352901552085348309}, + {9.3125, 5537.80123121853803935727335892054791265}, + {9.3750, 5894.95873086734181634245918412592155656}, + {9.4375, 6275.15090986233399457103055108344546942}, + {9.5000, 6679.86337740502119410058225086262108741}, + {9.5625, 7110.67755625726876329967852256934334025}, + {9.6250, 7569.27686218510919585241049433331592115}, + {9.6875, 8057.45328194243077504648484392156371121}, + {9.7500, 8577.11437549816065709098061006273039092}, + {9.8125, 9130.29072986829727910801024120918114778}, + {9.8750, 9719.14389367880274015504995181862860062}, + {9.9375, 10345.97482346383208590278839409938269134}, + {10.0000, 11013.23287470339337723652455484636420303}, + }; + + for(int i = 0; i < testCases.length; i++) { + double [] testCase = testCases[i]; + failures += testSinhCaseWithUlpDiff(testCase[0], + testCase[1], + 3.0); + } + + double [][] specialTestCases = { + {0.0, 0.0}, + {NaNd, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, + {Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY} + }; + + for(int i = 0; i < specialTestCases.length; i++) { + failures += testSinhCaseWithUlpDiff(specialTestCases[i][0], + specialTestCases[i][1], + 0.0); + } + + // For powers of 2 less than 2^(-27), the second and + // subsequent terms of the Taylor series expansion will get + // rounded away since |n-n^3| > 53, the binary precision of a + // double significand. + + for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) { + double d = FpUtils.scalb(2.0, i); + + // Result and expected are the same. + failures += testSinhCaseWithUlpDiff(d, d, 2.5); + } + + // For values of x larger than 22, the e^(-x) term is + // insignificant to the floating-point result. Util exp(x) + // overflows around 709.8, sinh(x) ~= exp(x)/2; will will test + // 10000 values in this range. + + long trans22 = Double.doubleToLongBits(22.0); + // (approximately) largest value such that exp shouldn't + // overflow + long transExpOvfl = Double.doubleToLongBits(FpUtils.nextDown(709.7827128933841)); + + for(long i = trans22; + i < transExpOvfl; + i +=(transExpOvfl-trans22)/10000) { + + double d = Double.longBitsToDouble(i); + + // Allow 3.5 ulps of error to deal with error in exp. + failures += testSinhCaseWithUlpDiff(d, StrictMath.exp(d)*0.5, 3.5); + } + + // (approximately) largest value such that sinh shouldn't + // overflow. + long transSinhOvfl = Double.doubleToLongBits(710.4758600739439); + + // Make sure sinh(x) doesn't overflow as soon as exp(x) + // overflows. + + /* + * For large values of x, sinh(x) ~= 0.5*(e^x). Therefore, + * + * sinh(x) ~= e^(ln 0.5) * e^x = e^(x + ln 0.5) + * + * So, we can calculate the approximate expected result as + * exp(x + -0.693147186). However, this sum suffers from + * roundoff, limiting the accuracy of the approximation. The + * accuracy can be improved by recovering the rounded-off + * information. Since x is larger than ln(0.5), the trailing + * bits of ln(0.5) get rounded away when the two values are + * added. However, high-order bits of ln(0.5) that + * contribute to the sum can be found: + * + * offset = log(0.5); + * effective_offset = (x + offset) - x; // exact subtraction + * rounded_away_offset = offset - effective_offset; // exact subtraction + * + * Therefore, the product + * + * exp(x + offset)*exp(rounded_away_offset) + * + * will be a better approximation to the exact value of + * + * e^(x + offset) + * + * than exp(x+offset) alone. (The expected result cannot be + * computed as exp(x)*exp(offset) since exp(x) by itself would + * overflow to infinity.) + */ + double offset = StrictMath.log(0.5); + for(long i = transExpOvfl+1; i < transSinhOvfl; + i += (transSinhOvfl-transExpOvfl)/1000 ) { + double input = Double.longBitsToDouble(i); + + double expected = + StrictMath.exp(input + offset) * + StrictMath.exp( offset - ((input + offset) - input) ); + + failures += testSinhCaseWithUlpDiff(input, expected, 4.0); + } + + // sinh(x) overflows for values greater than 710; in + // particular, it overflows for all 2^i, i > 10. + for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) { + double d = FpUtils.scalb(2.0, i); + + // Result and expected are the same. + failures += testSinhCaseWithUlpDiff(d, + Double.POSITIVE_INFINITY, 0.0); + } + + return failures; + } + + public static int testSinhCaseWithTolerance(double input, + double expected, + double tolerance) { + int failures = 0; + failures += Tests.testTolerance("Math.sinh(double)", + input, Math.sinh(input), + expected, tolerance); + failures += Tests.testTolerance("Math.sinh(double)", + -input, Math.sinh(-input), + -expected, tolerance); + + failures += Tests.testTolerance("StrictMath.sinh(double)", + input, StrictMath.sinh(input), + expected, tolerance); + failures += Tests.testTolerance("StrictMath.sinh(double)", + -input, StrictMath.sinh(-input), + -expected, tolerance); + return failures; + } + + public static int testSinhCaseWithUlpDiff(double input, + double expected, + double ulps) { + int failures = 0; + failures += Tests.testUlpDiff("Math.sinh(double)", + input, Math.sinh(input), + expected, ulps); + failures += Tests.testUlpDiff("Math.sinh(double)", + -input, Math.sinh(-input), + -expected, ulps); + + failures += Tests.testUlpDiff("StrictMath.sinh(double)", + input, StrictMath.sinh(input), + expected, ulps); + failures += Tests.testUlpDiff("StrictMath.sinh(double)", + -input, StrictMath.sinh(-input), + -expected, ulps); + return failures; + } + + + /** + * Test accuracy of {Math, StrictMath}.cosh. The specified + * accuracy is 2.5 ulps. + * + * The defintion of cosh(x) is + * + * (e^x + e^(-x))/2 + * + * The series expansion of cosh(x) = + * + * 1 + x^2/2! + x^4/4! + x^6/6! +... + * + * Therefore, + * + * 1. For large values of x cosh(x) ~= exp(|x|)/2 + * + * 2. For small values of x, cosh(x) ~= 1. + * + * Additionally, cosh is an even function; cosh(-x) = cosh(x). + * + */ + static int testCosh() { + int failures = 0; + /* + * Array elements below generated using a quad cosh + * implementation. Rounded to a double, the quad result + * *should* be correctly rounded, unless we are quite unlucky. + * Assuming the quad value is a correctly rounded double, the + * allowed error is 3.0 ulps instead of 2.5 since the quad + * value rounded to double can have its own 1/2 ulp error. + */ + double [][] testCases = { + // x cosh(x) + {0.0625, 1.001953760865667607841550709632597376}, + {0.1250, 1.007822677825710859846949685520422223}, + {0.1875, 1.017629683800690526835115759894757615}, + {0.2500, 1.031413099879573176159295417520378622}, + {0.3125, 1.049226785060219076999158096606305793}, + {0.3750, 1.071140346704586767299498015567016002}, + {0.4375, 1.097239412531012567673453832328262160}, + {0.5000, 1.127625965206380785226225161402672030}, + {0.5625, 1.162418740845610783505338363214045218}, + {0.6250, 1.201753692975606324229229064105075301}, + {0.6875, 1.245784523776616395403056980542275175}, + {0.7500, 1.294683284676844687841708185390181730}, + {0.8125, 1.348641048647144208352285714214372703}, + {0.8750, 1.407868656822803158638471458026344506}, + {0.9375, 1.472597542369862933336886403008640891}, + {1.0000, 1.543080634815243778477905620757061497}, + {1.0625, 1.619593348374367728682469968448090763}, + {1.1250, 1.702434658138190487400868008124755757}, + {1.1875, 1.791928268324866464246665745956119612}, + {1.2500, 1.888423877161015738227715728160051696}, + {1.3125, 1.992298543335143985091891077551921106}, + {1.3750, 2.103958159362661802010972984204389619}, + {1.4375, 2.223839037619709260803023946704272699}, + {1.5000, 2.352409615243247325767667965441644201}, + {1.5625, 2.490172284559350293104864895029231913}, + {1.6250, 2.637665356192137582275019088061812951}, + {1.6875, 2.795465162524235691253423614360562624}, + {1.7500, 2.964188309728087781773608481754531801}, + {1.8125, 3.144494087167972176411236052303565201}, + {1.8750, 3.337087043587520514308832278928116525}, + {1.9375, 3.542719740149244276729383650503145346}, + {2.0000, 3.762195691083631459562213477773746099}, + {2.0625, 3.996372503438463642260225717607554880}, + {2.1250, 4.246165228196992140600291052990934410}, + {2.1875, 4.512549935859540340856119781585096760}, + {2.2500, 4.796567530460195028666793366876218854}, + {2.3125, 5.099327816921939817643745917141739051}, + {2.3750, 5.422013837643509250646323138888569746}, + {2.4375, 5.765886495263270945949271410819116399}, + {2.5000, 6.132289479663686116619852312817562517}, + {2.5625, 6.522654518468725462969589397439224177}, + {2.6250, 6.938506971550673190999796241172117288}, + {2.6875, 7.381471791406976069645686221095397137}, + {2.7500, 7.853279872697439591457564035857305647}, + {2.8125, 8.355774815752725814638234943192709129}, + {2.8750, 8.890920130482709321824793617157134961}, + {2.9375, 9.460806908834119747071078865866737196}, + {3.0000, 10.067661995777765841953936035115890343}, + {3.0625, 10.713856690753651225304006562698007312}, + {3.1250, 11.401916013575067700373788969458446177}, + {3.1875, 12.134528570998387744547733730974713055}, + {3.2500, 12.914557062512392049483503752322408761}, + {3.3125, 13.745049466398732213877084541992751273}, + {3.3750, 14.629250949773302934853381428660210721}, + {3.4375, 15.570616549147269180921654324879141947}, + {3.5000, 16.572824671057316125696517821376119469}, + {3.5625, 17.639791465519127930722105721028711044}, + {3.6250, 18.775686128468677200079039891415789429}, + {3.6875, 19.984947192985946987799359614758598457}, + {3.7500, 21.272299872959396081877161903352144126}, + {3.8125, 22.642774526961913363958587775566619798}, + {3.8750, 24.101726314486257781049388094955970560}, + {3.9375, 25.654856121347151067170940701379544221}, + {4.0000, 27.308232836016486629201989612067059978}, + {4.0625, 29.068317063936918520135334110824828950}, + {4.1250, 30.941986372478026192360480044849306606}, + {4.1875, 32.936562165180269851350626768308756303}, + {4.2500, 35.059838290298428678502583470475012235}, + {4.3125, 37.320111495433027109832850313172338419}, + {4.3750, 39.726213847251883288518263854094284091}, + {4.4375, 42.287547242982546165696077854963452084}, + {4.5000, 45.014120148530027928305799939930642658}, + {4.5625, 47.916586706774825161786212701923307169}, + {4.6250, 51.006288368867753140854830589583165950}, + {4.6875, 54.295298211196782516984520211780624960}, + {4.7500, 57.796468111195389383795669320243166117}, + {4.8125, 61.523478966332915041549750463563672435}, + {4.8750, 65.490894152518731617237739112888213645}, + {4.9375, 69.714216430810089539924900313140922323}, + {5.0000, 74.209948524787844444106108044487704798}, + {5.0625, 78.995657605307475581204965926043112946}, + {5.1250, 84.090043934600961683400343038519519678}, + {5.1875, 89.513013937957834087706670952561002466}, + {5.2500, 95.285757988514588780586084642381131013}, + {5.3125, 101.430833209098212357990123684449846912}, + {5.3750, 107.972251614673824873137995865940755392}, + {5.4375, 114.935573939814969189535554289886848550}, + {5.5000, 122.348009517829425991091207107262038316}, + {5.5625, 130.238522601820409078244923165746295574}, + {5.6250, 138.637945543134998069351279801575968875}, + {5.6875, 147.579099269447055276899288971207106581}, + {5.7500, 157.096921533245353905868840194264636395}, + {5.8125, 167.228603431860671946045256541679445836}, + {5.8750, 178.013734732486824390148614309727161925}, + {5.9375, 189.494458570056311567917444025807275896}, + {6.0000, 201.715636122455894483405112855409538488}, + {6.0625, 214.725021906554080628430756558271312513}, + {6.1250, 228.573450380013557089736092321068279231}, + {6.1875, 243.315034578039208138752165587134488645}, + {6.2500, 259.007377561239126824465367865430519592}, + {6.3125, 275.711797500835732516530131577254654076}, + {6.3750, 293.493567280752348242602902925987643443}, + {6.4375, 312.422169552825597994104814531010579387}, + {6.5000, 332.571568241777409133204438572983297292}, + {6.5625, 354.020497560858198165985214519757890505}, + {6.6250, 376.852769667496146326030849450983914197}, + {6.6875, 401.157602161123700280816957271992998156}, + {6.7500, 427.029966702886171977469256622451185850}, + {6.8125, 454.570960119471524953536004647195906721}, + {6.8750, 483.888199441157626584508920036981010995}, + {6.9375, 515.096242417696720610477570797503766179}, + {7.0000, 548.317035155212076889964120712102928484}, + {7.0625, 583.680388623257719787307547662358502345}, + {7.1250, 621.324485894002926216918634755431456031}, + {7.1875, 661.396422095589629755266517362992812037}, + {7.2500, 704.052779189542208784574955807004218856}, + {7.3125, 749.460237818184878095966335081928645934}, + {7.3750, 797.796228612873763671070863694973560629}, + {7.4375, 849.249625508044731271830060572510241864}, + {7.5000, 904.021483770216677368692292389446994987}, + {7.5625, 962.325825625814651122171697031114091993}, + {7.6250, 1024.390476557670599008492465853663578558}, + {7.6875, 1090.457955538048482588540574008226583335}, + {7.7500, 1160.786422676798661020094043586456606003}, + {7.8125, 1235.650687987597295222707689125107720568}, + {7.8750, 1315.343285214046776004329388551335841550}, + {7.9375, 1400.175614911635999247504386054087931958}, + {8.0000, 1490.479161252178088627715460421007179728}, + {8.0625, 1586.606787305415349050508956232945539108}, + {8.1250, 1688.934113859132470361718199038326340668}, + {8.1875, 1797.860987165547537276364148450577336075}, + {8.2500, 1913.813041349231764486365114317586148767}, + {8.3125, 2037.243361581700856522236313401822532385}, + {8.3750, 2168.634254521568851112005905503069409349}, + {8.4375, 2308.499132938297821208734949028296170563}, + {8.5000, 2457.384521883751693037774022640629666294}, + {8.5625, 2615.872194250713123494312356053193077854}, + {8.6250, 2784.581444063104750127653362960649823247}, + {8.6875, 2964.171506380845754878370650565756538203}, + {8.7500, 3155.344133275174556354775488913749659006}, + {8.8125, 3358.846335940117183452010789979584950102}, + {8.8750, 3575.473303654961482727206202358956274888}, + {8.9375, 3806.071511003646460448021740303914939059}, + {9.0000, 4051.542025492594047194773093534725371440}, + {9.0625, 4312.844028491571841588188869958240355518}, + {9.1250, 4590.998563255739769060078863130940205710}, + {9.1875, 4887.092524674358252509551443117048351290}, + {9.2500, 5202.282906336187674588222835339193136030}, + {9.3125, 5537.801321507079474415176386655744387251}, + {9.3750, 5894.958815685577062811620236195525504885}, + {9.4375, 6275.150989541692149890530417987358096221}, + {9.5000, 6679.863452256851081801173722051940058824}, + {9.5625, 7110.677626574055535297758456126491707647}, + {9.6250, 7569.276928241617224537226019600213961572}, + {9.6875, 8057.453343996777301036241026375049070162}, + {9.7500, 8577.114433792824387959788368429252257664}, + {9.8125, 9130.290784631065880205118262838330689429}, + {9.8750, 9719.143945123662919857326995631317996715}, + {9.9375, 10345.974871791805753327922796701684092861}, + {10.0000, 11013.232920103323139721376090437880844591}, + }; + + for(int i = 0; i < testCases.length; i++) { + double [] testCase = testCases[i]; + failures += testCoshCaseWithUlpDiff(testCase[0], + testCase[1], + 3.0); + } + + + double [][] specialTestCases = { + {0.0, 1.0}, + {NaNd, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, + {Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY} + }; + + for(int i = 0; i < specialTestCases.length; i++ ) { + failures += testCoshCaseWithUlpDiff(specialTestCases[i][0], + specialTestCases[i][1], + 0.0); + } + + // For powers of 2 less than 2^(-27), the second and + // subsequent terms of the Taylor series expansion will get + // rounded. + + for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) { + double d = FpUtils.scalb(2.0, i); + + // Result and expected are the same. + failures += testCoshCaseWithUlpDiff(d, 1.0, 2.5); + } + + // For values of x larger than 22, the e^(-x) term is + // insignificant to the floating-point result. Util exp(x) + // overflows around 709.8, cosh(x) ~= exp(x)/2; will will test + // 10000 values in this range. + + long trans22 = Double.doubleToLongBits(22.0); + // (approximately) largest value such that exp shouldn't + // overflow + long transExpOvfl = Double.doubleToLongBits(FpUtils.nextDown(709.7827128933841)); + + for(long i = trans22; + i < transExpOvfl; + i +=(transExpOvfl-trans22)/10000) { + + double d = Double.longBitsToDouble(i); + + // Allow 3.5 ulps of error to deal with error in exp. + failures += testCoshCaseWithUlpDiff(d, StrictMath.exp(d)*0.5, 3.5); + } + + // (approximately) largest value such that cosh shouldn't + // overflow. + long transCoshOvfl = Double.doubleToLongBits(710.4758600739439); + + // Make sure sinh(x) doesn't overflow as soon as exp(x) + // overflows. + + /* + * For large values of x, cosh(x) ~= 0.5*(e^x). Therefore, + * + * cosh(x) ~= e^(ln 0.5) * e^x = e^(x + ln 0.5) + * + * So, we can calculate the approximate expected result as + * exp(x + -0.693147186). However, this sum suffers from + * roundoff, limiting the accuracy of the approximation. The + * accuracy can be improved by recovering the rounded-off + * information. Since x is larger than ln(0.5), the trailing + * bits of ln(0.5) get rounded away when the two values are + * added. However, high-order bits of ln(0.5) that + * contribute to the sum can be found: + * + * offset = log(0.5); + * effective_offset = (x + offset) - x; // exact subtraction + * rounded_away_offset = offset - effective_offset; // exact subtraction + * + * Therefore, the product + * + * exp(x + offset)*exp(rounded_away_offset) + * + * will be a better approximation to the exact value of + * + * e^(x + offset) + * + * than exp(x+offset) alone. (The expected result cannot be + * computed as exp(x)*exp(offset) since exp(x) by itself would + * overflow to infinity.) + */ + double offset = StrictMath.log(0.5); + for(long i = transExpOvfl+1; i < transCoshOvfl; + i += (transCoshOvfl-transExpOvfl)/1000 ) { + double input = Double.longBitsToDouble(i); + + double expected = + StrictMath.exp(input + offset) * + StrictMath.exp( offset - ((input + offset) - input) ); + + failures += testCoshCaseWithUlpDiff(input, expected, 4.0); + } + + // cosh(x) overflows for values greater than 710; in + // particular, it overflows for all 2^i, i > 10. + for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) { + double d = FpUtils.scalb(2.0, i); + + // Result and expected are the same. + failures += testCoshCaseWithUlpDiff(d, + Double.POSITIVE_INFINITY, 0.0); + } + return failures; + } + + public static int testCoshCaseWithTolerance(double input, + double expected, + double tolerance) { + int failures = 0; + failures += Tests.testTolerance("Math.cosh(double)", + input, Math.cosh(input), + expected, tolerance); + failures += Tests.testTolerance("Math.cosh(double)", + -input, Math.cosh(-input), + expected, tolerance); + + failures += Tests.testTolerance("StrictMath.cosh(double)", + input, StrictMath.cosh(input), + expected, tolerance); + failures += Tests.testTolerance("StrictMath.cosh(double)", + -input, StrictMath.cosh(-input), + expected, tolerance); + return failures; + } + + public static int testCoshCaseWithUlpDiff(double input, + double expected, + double ulps) { + int failures = 0; + failures += Tests.testUlpDiff("Math.cosh(double)", + input, Math.cosh(input), + expected, ulps); + failures += Tests.testUlpDiff("Math.cosh(double)", + -input, Math.cosh(-input), + expected, ulps); + + failures += Tests.testUlpDiff("StrictMath.cosh(double)", + input, StrictMath.cosh(input), + expected, ulps); + failures += Tests.testUlpDiff("StrictMath.cosh(double)", + -input, StrictMath.cosh(-input), + expected, ulps); + return failures; + } + + + /** + * Test accuracy of {Math, StrictMath}.tanh. The specified + * accuracy is 2.5 ulps. + * + * The defintion of tanh(x) is + * + * (e^x - e^(-x))/(e^x + e^(-x)) + * + * The series expansion of tanh(x) = + * + * x - x^3/3 + 2x^5/15 - 17x^7/315 + ... + * + * Therefore, + * + * 1. For large values of x tanh(x) ~= signum(x) + * + * 2. For small values of x, tanh(x) ~= x. + * + * Additionally, tanh is an odd function; tanh(-x) = -tanh(x). + * + */ + static int testTanh() { + int failures = 0; + /* + * Array elements below generated using a quad sinh + * implementation. Rounded to a double, the quad result + * *should* be correctly rounded, unless we are quite unlucky. + * Assuming the quad value is a correctly rounded double, the + * allowed error is 3.0 ulps instead of 2.5 since the quad + * value rounded to double can have its own 1/2 ulp error. + */ + double [][] testCases = { + // x tanh(x) + {0.0625, 0.06241874674751251449014289119421133}, + {0.1250, 0.12435300177159620805464727580589271}, + {0.1875, 0.18533319990813951753211997502482787}, + {0.2500, 0.24491866240370912927780113149101697}, + {0.3125, 0.30270972933210848724239738970991712}, + {0.3750, 0.35835739835078594631936023155315807}, + {0.4375, 0.41157005567402245143207555859415687}, + {0.5000, 0.46211715726000975850231848364367256}, + {0.5625, 0.50982997373525658248931213507053130}, + {0.6250, 0.55459972234938229399903909532308371}, + {0.6875, 0.59637355547924233984437303950726939}, + {0.7500, 0.63514895238728731921443435731249638}, + {0.8125, 0.67096707420687367394810954721913358}, + {0.8750, 0.70390560393662106058763026963135371}, + {0.9375, 0.73407151960434149263991588052503660}, + {1.0000, 0.76159415595576488811945828260479366}, + {1.0625, 0.78661881210869761781941794647736081}, + {1.1250, 0.80930107020178101206077047354332696}, + {1.1875, 0.82980190998595952708572559629034476}, + {1.2500, 0.84828363995751289761338764670750445}, + {1.3125, 0.86490661772074179125443141102709751}, + {1.3750, 0.87982669965198475596055310881018259}, + {1.4375, 0.89319334040035153149249598745889365}, + {1.5000, 0.90514825364486643824230369645649557}, + {1.5625, 0.91582454416876231820084311814416443}, + {1.6250, 0.92534622531174107960457166792300374}, + {1.6875, 0.93382804322259173763570528576138652}, + {1.7500, 0.94137553849728736226942088377163687}, + {1.8125, 0.94808528560440629971240651310180052}, + {1.8750, 0.95404526017994877009219222661968285}, + {1.9375, 0.95933529331468249183399461756952555}, + {2.0000, 0.96402758007581688394641372410092317}, + {2.0625, 0.96818721657637057702714316097855370}, + {2.1250, 0.97187274591350905151254495374870401}, + {2.1875, 0.97513669829362836159665586901156483}, + {2.2500, 0.97802611473881363992272924300618321}, + {2.3125, 0.98058304703705186541999427134482061}, + {2.3750, 0.98284502917257603002353801620158861}, + {2.4375, 0.98484551746427837912703608465407824}, + {2.5000, 0.98661429815143028888127603923734964}, + {2.5625, 0.98817786228751240824802592958012269}, + {2.6250, 0.98955974861288320579361709496051109}, + {2.6875, 0.99078085564125158320311117560719312}, + {2.7500, 0.99185972456820774534967078914285035}, + {2.8125, 0.99281279483715982021711715899682324}, + {2.8750, 0.99365463431502962099607366282699651}, + {2.9375, 0.99439814606575805343721743822723671}, + {3.0000, 0.99505475368673045133188018525548849}, + {3.0625, 0.99563456710930963835715538507891736}, + {3.1250, 0.99614653067334504917102591131792951}, + {3.1875, 0.99659855517712942451966113109487039}, + {3.2500, 0.99699763548652601693227592643957226}, + {3.3125, 0.99734995516557367804571991063376923}, + {3.3750, 0.99766097946988897037219469409451602}, + {3.4375, 0.99793553792649036103161966894686844}, + {3.5000, 0.99817789761119870928427335245061171}, + {3.5625, 0.99839182812874152902001617480606320}, + {3.6250, 0.99858065920179882368897879066418294}, + {3.6875, 0.99874733168378115962760304582965538}, + {3.7500, 0.99889444272615280096784208280487888}, + {3.8125, 0.99902428575443546808677966295308778}, + {3.8750, 0.99913888583735077016137617231569011}, + {3.9375, 0.99924003097049627100651907919688313}, + {4.0000, 0.99932929973906704379224334434172499}, + {4.0625, 0.99940808577297384603818654530731215}, + {4.1250, 0.99947761936180856115470576756499454}, + {4.1875, 0.99953898655601372055527046497863955}, + {4.2500, 0.99959314604388958696521068958989891}, + {4.3125, 0.99964094406130644525586201091350343}, + {4.3750, 0.99968312756179494813069349082306235}, + {4.4375, 0.99972035584870534179601447812936151}, + {4.5000, 0.99975321084802753654050617379050162}, + {4.5625, 0.99978220617994689112771768489030236}, + {4.6250, 0.99980779516900105210240981251048167}, + {4.6875, 0.99983037791655283849546303868853396}, + {4.7500, 0.99985030754497877753787358852000255}, + {4.8125, 0.99986789571029070417475400133989992}, + {4.8750, 0.99988341746867772271011794614780441}, + {4.9375, 0.99989711557251558205051185882773206}, + {5.0000, 0.99990920426259513121099044753447306}, + {5.0625, 0.99991987261554158551063867262784721}, + {5.1250, 0.99992928749851651137225712249720606}, + {5.1875, 0.99993759617721206697530526661105307}, + {5.2500, 0.99994492861777083305830639416802036}, + {5.3125, 0.99995139951851344080105352145538345}, + {5.3750, 0.99995711010315817210152906092289064}, + {5.4375, 0.99996214970350792531554669737676253}, + {5.5000, 0.99996659715630380963848952941756868}, + {5.5625, 0.99997052203605101013786592945475432}, + {5.6250, 0.99997398574306704793434088941484766}, + {5.6875, 0.99997704246374583929961850444364696}, + {5.7500, 0.99997974001803825215761760428815437}, + {5.8125, 0.99998212060739040166557477723121777}, + {5.8750, 0.99998422147482750993344503195672517}, + {5.9375, 0.99998607548749972326220227464612338}, + {6.0000, 0.99998771165079557056434885235523206}, + {6.0625, 0.99998915556205996764518917496149338}, + {6.1250, 0.99999042981101021976277974520745310}, + {6.1875, 0.99999155433311068015449574811497719}, + {6.2500, 0.99999254672143162687722782398104276}, + {6.3125, 0.99999342250186907900400800240980139}, + {6.3750, 0.99999419537602957780612639767025158}, + {6.4375, 0.99999487743557848265406225515388994}, + {6.5000, 0.99999547935140419285107893831698753}, + {6.5625, 0.99999601054055694588617385671796346}, + {6.6250, 0.99999647931357331502887600387959900}, + {6.6875, 0.99999689300449080997594368612277442}, + {6.7500, 0.99999725808558628431084200832778748}, + {6.8125, 0.99999758026863294516387464046135924}, + {6.8750, 0.99999786459425991170635407313276785}, + {6.9375, 0.99999811551081218572759991597586905}, + {7.0000, 0.99999833694394467173571641595066708}, + {7.0625, 0.99999853235803894918375164252059190}, + {7.1250, 0.99999870481040359014665019356422927}, + {7.1875, 0.99999885699910593255108365463415411}, + {7.2500, 0.99999899130518359709674536482047025}, + {7.3125, 0.99999910982989611769943303422227663}, + {7.3750, 0.99999921442759946591163427422888252}, + {7.4375, 0.99999930673475777603853435094943258}, + {7.5000, 0.99999938819554614875054970643513124}, + {7.5625, 0.99999946008444508183970109263856958}, + {7.6250, 0.99999952352618001331402589096040117}, + {7.6875, 0.99999957951331792817413683491979752}, + {7.7500, 0.99999962892179632633374697389145081}, + {7.8125, 0.99999967252462750190604116210421169}, + {7.8750, 0.99999971100399253750324718031574484}, + {7.9375, 0.99999974496191422474977283863588658}, + {8.0000, 0.99999977492967588981001883295636840}, + {8.0625, 0.99999980137613348259726597081723424}, + {8.1250, 0.99999982471505097353529823063673263}, + {8.1875, 0.99999984531157382142423402736529911}, + {8.2500, 0.99999986348794179107425910499030547}, + {8.3125, 0.99999987952853049895833839645847571}, + {8.3750, 0.99999989368430056302584289932834041}, + {8.4375, 0.99999990617672396471542088609051728}, + {8.5000, 0.99999991720124905211338798152800748}, + {8.5625, 0.99999992693035839516545287745322387}, + {8.6250, 0.99999993551626733394129009365703767}, + {8.6875, 0.99999994309330543951799157347876934}, + {8.7500, 0.99999994978001814614368429416607424}, + {8.8125, 0.99999995568102143535399207289008504}, + {8.8750, 0.99999996088863858914831986187674522}, + {8.9375, 0.99999996548434461974481685677429908}, + {9.0000, 0.99999996954004097447930211118358244}, + {9.0625, 0.99999997311918045901919121395899372}, + {9.1250, 0.99999997627775997868467948564005257}, + {9.1875, 0.99999997906519662964368381583648379}, + {9.2500, 0.99999998152510084671976114264303159}, + {9.3125, 0.99999998369595870397054673668361266}, + {9.3750, 0.99999998561173404286033236040150950}, + {9.4375, 0.99999998730239984852716512979473289}, + {9.5000, 0.99999998879440718770812040917618843}, + {9.5625, 0.99999999011109904501789298212541698}, + {9.6250, 0.99999999127307553219220251303121960}, + {9.6875, 0.99999999229851618412119275358396363}, + {9.7500, 0.99999999320346438410630581726217930}, + {9.8125, 0.99999999400207836827291739324060736}, + {9.8750, 0.99999999470685273619047001387577653}, + {9.9375, 0.99999999532881393331131526966058758}, + {10.0000, 0.99999999587769276361959283713827574}, + }; + + for(int i = 0; i < testCases.length; i++) { + double [] testCase = testCases[i]; + failures += testTanhCaseWithUlpDiff(testCase[0], + testCase[1], + 3.0); + } + + + double [][] specialTestCases = { + {0.0, 0.0}, + {NaNd, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, + {Double.POSITIVE_INFINITY, 1.0} + }; + + for(int i = 0; i < specialTestCases.length; i++) { + failures += testTanhCaseWithUlpDiff(specialTestCases[i][0], + specialTestCases[i][1], + 0.0); + } + + // For powers of 2 less than 2^(-27), the second and + // subsequent terms of the Taylor series expansion will get + // rounded away since |n-n^3| > 53, the binary precision of a + // double significand. + + for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) { + double d = FpUtils.scalb(2.0, i); + + // Result and expected are the same. + failures += testTanhCaseWithUlpDiff(d, d, 2.5); + } + + // For values of x larger than 22, tanh(x) is 1.0 in double + // floating-point arithmetic. + + for(int i = 22; i < 32; i++) { + failures += testTanhCaseWithUlpDiff(i, 1.0, 2.5); + } + + for(int i = 5; i <= DoubleConsts.MAX_EXPONENT; i++) { + double d = FpUtils.scalb(2.0, i); + + failures += testTanhCaseWithUlpDiff(d, 1.0, 2.5); + } + + return failures; + } + + public static int testTanhCaseWithTolerance(double input, + double expected, + double tolerance) { + int failures = 0; + failures += Tests.testTolerance("Math.tanh(double", + input, Math.tanh(input), + expected, tolerance); + failures += Tests.testTolerance("Math.tanh(double", + -input, Math.tanh(-input), + -expected, tolerance); + + failures += Tests.testTolerance("StrictMath.tanh(double", + input, StrictMath.tanh(input), + expected, tolerance); + failures += Tests.testTolerance("StrictMath.tanh(double", + -input, StrictMath.tanh(-input), + -expected, tolerance); + return failures; + } + + public static int testTanhCaseWithUlpDiff(double input, + double expected, + double ulps) { + int failures = 0; + + failures += Tests.testUlpDiffWithAbsBound("Math.tanh(double)", + input, Math.tanh(input), + expected, ulps, 1.0); + failures += Tests.testUlpDiffWithAbsBound("Math.tanh(double)", + -input, Math.tanh(-input), + -expected, ulps, 1.0); + + failures += Tests.testUlpDiffWithAbsBound("StrictMath.tanh(double)", + input, StrictMath.tanh(input), + expected, ulps, 1.0); + failures += Tests.testUlpDiffWithAbsBound("StrictMath.tanh(double)", + -input, StrictMath.tanh(-input), + -expected, ulps, 1.0); + return failures; + } + + + public static void main(String argv[]) { + int failures = 0; + + failures += testSinh(); + failures += testCosh(); + failures += testTanh(); + + if (failures > 0) { + System.err.println("Testing the hyperbolic functions incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } + +} --- /dev/null Mon Jan 26 16:12:25 2009 +++ new/test/java/lang/Math/HypotTests.java Mon Jan 26 16:12:24 2009 @@ -0,0 +1,245 @@ +/* + * Copyright 2003 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 4851638 4939441 + * @summary Tests for {Math, StrictMath}.hypot + * @author Joseph D. Darcy + */ + +import sun.misc.DoubleConsts; +import sun.misc.FpUtils; + +public class HypotTests { + private HypotTests(){} + + static final double infinityD = Double.POSITIVE_INFINITY; + static final double NaNd = Double.NaN; + + /** + * Given integers m and n, assuming m < n, the triple (n^2 - m^2, + * 2mn, and n^2 + m^2) is a Pythagorean triple with a^2 + b^2 = + * c^2. This methods returns a long array holding the Pythagorean + * triple corresponding to the inputs. + */ + static long [] pythagoreanTriple(int m, int n) { + long M = m; + long N = n; + long result[] = new long[3]; + + + result[0] = Math.abs(M*M - N*N); + result[1] = Math.abs(2*M*N); + result[2] = Math.abs(M*M + N*N); + + return result; + } + + static int testHypot() { + int failures = 0; + + double [][] testCases = { + // Special cases + {infinityD, infinityD, infinityD}, + {infinityD, 0.0, infinityD}, + {infinityD, 1.0, infinityD}, + {infinityD, NaNd, infinityD}, + {NaNd, NaNd, NaNd}, + {0.0, NaNd, NaNd}, + {1.0, NaNd, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), 1.0, NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), 1.0, NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), 1.0, NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), 1.0, NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), 1.0, NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), 1.0, NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), 1.0, NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), 1.0, NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), 1.0, NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), 1.0, NaNd}, + }; + + for(int i = 0; i < testCases.length; i++) { + failures += testHypotCase(testCases[i][0], testCases[i][1], + testCases[i][2]); + } + + // Verify hypot(x, 0.0) is close to x over the entire exponent + // range. + for(int i = DoubleConsts.MIN_SUB_EXPONENT; + i <= DoubleConsts.MAX_EXPONENT; + i++) { + double input = FpUtils.scalb(2, i); + failures += testHypotCase(input, 0.0, input); + } + + + // Test Pythagorean triples + + // Small ones + for(int m = 1; m < 10; m++) { + for(int n = m+1; n < 11; n++) { + long [] result = pythagoreanTriple(m, n); + failures += testHypotCase(result[0], result[1], result[2]); + } + } + + // Big ones + for(int m = 100000; m < 100100; m++) { + for(int n = m+100000; n < 200200; n++) { + long [] result = pythagoreanTriple(m, n); + failures += testHypotCase(result[0], result[1], result[2]); + } + } + + // Approaching overflow tests + + /* + * Create a random value r with an large-ish exponent. The + * result of hypot(3*r, 4*r) should be approximately 5*r. (The + * computation of 4*r is exact since it just changes the + * exponent). While the exponent of r is less than or equal + * to (MAX_EXPONENT - 3), the computation should not overflow. + */ + java.util.Random rand = new java.util.Random(); + for(int i = 0; i < 1000; i++) { + double d = rand.nextDouble(); + // Scale d to have an exponent equal to MAX_EXPONENT -15 + d = FpUtils.scalb(d, DoubleConsts.MAX_EXPONENT + -15 - FpUtils.ilogb(d)); + for(int j = 0; j <= 13; j += 1) { + failures += testHypotCase(3*d, 4*d, 5*d, 2.5); + d *= 2.0; // increase exponent by 1 + } + } + + // Test for monotonicity failures. Fix one argument and test + // two numbers before and two numbers after each chosen value; + // i.e. + // + // pcNeighbors[] = + // {nextDown(nextDown(pc)), + // nextDown(pc), + // pc, + // nextUp(pc), + // nextUp(nextUp(pc))} + // + // and we test that hypot(pcNeighbors[i]) <= hypot(pcNeighbors[i+1]) + { + double pcNeighbors[] = new double[5]; + double pcNeighborsHypot[] = new double[5]; + double pcNeighborsStrictHypot[] = new double[5]; + + + for(int i = -18; i <= 18; i++) { + double pc = FpUtils.scalb(1.0, i); + + pcNeighbors[2] = pc; + pcNeighbors[1] = FpUtils.nextDown(pc); + pcNeighbors[0] = FpUtils.nextDown(pcNeighbors[1]); + pcNeighbors[3] = FpUtils.nextUp(pc); + pcNeighbors[4] = FpUtils.nextUp(pcNeighbors[3]); + + for(int j = 0; j < pcNeighbors.length; j++) { + pcNeighborsHypot[j] = Math.hypot(2.0, pcNeighbors[j]); + pcNeighborsStrictHypot[j] = StrictMath.hypot(2.0, pcNeighbors[j]); + } + + for(int j = 0; j < pcNeighborsHypot.length-1; j++) { + if(pcNeighborsHypot[j] > pcNeighborsHypot[j+1] ) { + failures++; + System.err.println("Monotonicity failure for Math.hypot on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsHypot[j] + " and " + + pcNeighborsHypot[j+1] ); + } + + if(pcNeighborsStrictHypot[j] > pcNeighborsStrictHypot[j+1] ) { + failures++; + System.err.println("Monotonicity failure for StrictMath.hypot on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsStrictHypot[j] + " and " + + pcNeighborsStrictHypot[j+1] ); + } + + + } + + } + } + + + return failures; + } + + static int testHypotCase(double input1, double input2, double expected) { + return testHypotCase(input1,input2, expected, 1); + } + + static int testHypotCase(double input1, double input2, double expected, + double ulps) { + int failures = 0; + if (expected < 0.0) { + throw new AssertionError("Result of hypot must be greater than " + + "or equal to zero"); + } + + // Test Math and StrictMath methods with no inputs negated, + // each input negated singly, and both inputs negated. Also + // test inputs in reversed order. + + for(int i = -1; i <= 1; i+=2) { + for(int j = -1; j <= 1; j+=2) { + double x = i * input1; + double y = j * input2; + failures += Tests.testUlpDiff("Math.hypot", x, y, + Math.hypot(x, y), expected, ulps); + failures += Tests.testUlpDiff("Math.hypot", y, x, + Math.hypot(y, x ), expected, ulps); + + failures += Tests.testUlpDiff("StrictMath.hypot", x, y, + StrictMath.hypot(x, y), expected, ulps); + failures += Tests.testUlpDiff("StrictMath.hypot", y, x, + StrictMath.hypot(y, x), expected, ulps); + } + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += testHypot(); + + if (failures > 0) { + System.err.println("Testing the hypot incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } + +} --- /dev/null Mon Jan 26 16:12:27 2009 +++ new/test/java/lang/Math/IeeeRecommendedTests.java Mon Jan 26 16:12:26 2009 @@ -0,0 +1,1705 @@ +/* + * Copyright 2003-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 4860891 4826732 4780454 4939441 4826652 + * @summary Tests for IEEE 754[R] recommended functions and similar methods + * @author Joseph D. Darcy + * @compile -source 1.5 IeeeRecommendedTests.java + * @run main IeeeRecommendedTests + */ + +import sun.misc.FpUtils; +import sun.misc.DoubleConsts; +import sun.misc.FloatConsts; + +public class IeeeRecommendedTests { + private IeeeRecommendedTests(){} + + static final float NaNf = Float.NaN; + static final double NaNd = Double.NaN; + static final float infinityF = Float.POSITIVE_INFINITY; + static final double infinityD = Double.POSITIVE_INFINITY; + + static final float Float_MAX_VALUEmm = 0x1.fffffcP+127f; + static final float Float_MAX_SUBNORMAL = 0x0.fffffeP-126f; + static final float Float_MAX_SUBNORMALmm = 0x0.fffffcP-126f; + + static final double Double_MAX_VALUEmm = 0x1.ffffffffffffeP+1023; + static final double Double_MAX_SUBNORMAL = 0x0.fffffffffffffP-1022; + static final double Double_MAX_SUBNORMALmm = 0x0.ffffffffffffeP-1022; + + // Initialize shared random number generator + static java.util.Random rand = new java.util.Random(); + + /** + * Returns a floating-point power of two in the normal range. + */ + static double powerOfTwoD(int n) { + return Double.longBitsToDouble((((long)n + (long)DoubleConsts.MAX_EXPONENT) << + (DoubleConsts.SIGNIFICAND_WIDTH-1)) + & DoubleConsts.EXP_BIT_MASK); + } + + /** + * Returns a floating-point power of two in the normal range. + */ + static float powerOfTwoF(int n) { + return Float.intBitsToFloat(((n + FloatConsts.MAX_EXPONENT) << + (FloatConsts.SIGNIFICAND_WIDTH-1)) + & FloatConsts.EXP_BIT_MASK); + } + + /* ******************** getExponent tests ****************************** */ + + /* + * The tests for getExponent should test the special values (NaN, +/- + * infinity, etc.), test the endpoints of each binade (set of + * floating-point values with the same exponent), and for good + * measure, test some random values within each binade. Testing + * the endpoints of each binade includes testing both positive and + * negative numbers. Subnormal values with different normalized + * exponents should be tested too. Both Math and StrictMath + * methods should return the same results. + */ + + /* + * Test Math.getExponent and StrictMath.getExponent with +d and -d. + */ + static int testGetExponentCase(float f, int expected) { + float minus_f = -f; + int failures=0; + + failures+=Tests.test("Math.getExponent(float)", f, + Math.getExponent(f), expected); + failures+=Tests.test("Math.getExponent(float)", minus_f, + Math.getExponent(minus_f), expected); + + failures+=Tests.test("StrictMath.getExponent(float)", f, + StrictMath.getExponent(f), expected); + failures+=Tests.test("StrictMath.getExponent(float)", minus_f, + StrictMath.getExponent(minus_f), expected); + return failures; + } + + /* + * Test Math.getExponent and StrictMath.getExponent with +d and -d. + */ + static int testGetExponentCase(double d, int expected) { + double minus_d = -d; + int failures=0; + + failures+=Tests.test("Math.getExponent(double)", d, + Math.getExponent(d), expected); + failures+=Tests.test("Math.getExponent(double)", minus_d, + Math.getExponent(minus_d), expected); + + failures+=Tests.test("StrictMath.getExponent(double)", d, + StrictMath.getExponent(d), expected); + failures+=Tests.test("StrictMath.getExponent(double)", minus_d, + StrictMath.getExponent(minus_d), expected); + return failures; + } + + public static int testFloatGetExponent() { + int failures = 0; + float [] specialValues = {NaNf, + Float.POSITIVE_INFINITY, + +0.0f, + +1.0f, + +2.0f, + +16.0f, + +Float.MIN_VALUE, + +Float_MAX_SUBNORMAL, + +FloatConsts.MIN_NORMAL, + +Float.MAX_VALUE + }; + + int [] specialResults = {Float.MAX_EXPONENT + 1, // NaN results + Float.MAX_EXPONENT + 1, // Infinite results + Float.MIN_EXPONENT - 1, // Zero results + 0, + 1, + 4, + FloatConsts.MIN_EXPONENT - 1, + -FloatConsts.MAX_EXPONENT, + FloatConsts.MIN_EXPONENT, + FloatConsts.MAX_EXPONENT + }; + + // Special value tests + for(int i = 0; i < specialValues.length; i++) { + failures += testGetExponentCase(specialValues[i], specialResults[i]); + } + + + // Normal exponent tests + for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) { + int result; + + // Create power of two + float po2 = powerOfTwoF(i); + + failures += testGetExponentCase(po2, i); + + // Generate some random bit patterns for the significand + for(int j = 0; j < 10; j++) { + int randSignif = rand.nextInt(); + float randFloat; + + randFloat = Float.intBitsToFloat( // Exponent + (Float.floatToIntBits(po2)& + (~FloatConsts.SIGNIF_BIT_MASK)) | + // Significand + (randSignif & + FloatConsts.SIGNIF_BIT_MASK) ); + + failures += testGetExponentCase(randFloat, i); + } + + if (i > FloatConsts.MIN_EXPONENT) { + float po2minus = FpUtils.nextAfter(po2, + Float.NEGATIVE_INFINITY); + failures += testGetExponentCase(po2minus, i-1); + } + } + + // Subnormal exponent tests + + /* + * Start with MIN_VALUE, left shift, test high value, low + * values, and random in between. + * + * Use nextAfter to calculate, high value of previous binade, + * loop count i will indicate how many random bits, if any are + * needed. + */ + + float top=Float.MIN_VALUE; + for( int i = 1; + i < FloatConsts.SIGNIFICAND_WIDTH; + i++, top *= 2.0f) { + + failures += testGetExponentCase(top, + FloatConsts.MIN_EXPONENT - 1); + + // Test largest value in next smaller binade + if (i >= 3) {// (i == 1) would test 0.0; + // (i == 2) would just retest MIN_VALUE + testGetExponentCase(FpUtils.nextAfter(top, 0.0f), + FloatConsts.MIN_EXPONENT - 1); + + if( i >= 10) { + // create a bit mask with (i-1) 1's in the low order + // bits + int mask = ~((~0)<<(i-1)); + float randFloat = Float.intBitsToFloat( // Exponent + Float.floatToIntBits(top) | + // Significand + (rand.nextInt() & mask ) ) ; + + failures += testGetExponentCase(randFloat, + FloatConsts.MIN_EXPONENT - 1); + } + } + } + + return failures; + } + + + public static int testDoubleGetExponent() { + int failures = 0; + double [] specialValues = {NaNd, + infinityD, + +0.0, + +1.0, + +2.0, + +16.0, + +Double.MIN_VALUE, + +Double_MAX_SUBNORMAL, + +DoubleConsts.MIN_NORMAL, + +Double.MAX_VALUE + }; + + int [] specialResults = {Double.MAX_EXPONENT + 1, // NaN results + Double.MAX_EXPONENT + 1, // Infinite results + Double.MIN_EXPONENT - 1, // Zero results + 0, + 1, + 4, + DoubleConsts.MIN_EXPONENT - 1, + -DoubleConsts.MAX_EXPONENT, + DoubleConsts.MIN_EXPONENT, + DoubleConsts.MAX_EXPONENT + }; + + // Special value tests + for(int i = 0; i < specialValues.length; i++) { + failures += testGetExponentCase(specialValues[i], specialResults[i]); + } + + + // Normal exponent tests + for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) { + int result; + + // Create power of two + double po2 = powerOfTwoD(i); + + failures += testGetExponentCase(po2, i); + + // Generate some random bit patterns for the significand + for(int j = 0; j < 10; j++) { + long randSignif = rand.nextLong(); + double randFloat; + + randFloat = Double.longBitsToDouble( // Exponent + (Double.doubleToLongBits(po2)& + (~DoubleConsts.SIGNIF_BIT_MASK)) | + // Significand + (randSignif & + DoubleConsts.SIGNIF_BIT_MASK) ); + + failures += testGetExponentCase(randFloat, i); + } + + if (i > DoubleConsts.MIN_EXPONENT) { + double po2minus = FpUtils.nextAfter(po2, + Double.NEGATIVE_INFINITY); + failures += testGetExponentCase(po2minus, i-1); + } + } + + // Subnormal exponent tests + + /* + * Start with MIN_VALUE, left shift, test high value, low + * values, and random in between. + * + * Use nextAfter to calculate, high value of previous binade; + * loop count i will indicate how many random bits, if any are + * needed. + */ + + double top=Double.MIN_VALUE; + for( int i = 1; + i < DoubleConsts.SIGNIFICAND_WIDTH; + i++, top *= 2.0f) { + + failures += testGetExponentCase(top, + DoubleConsts.MIN_EXPONENT - 1); + + // Test largest value in next smaller binade + if (i >= 3) {// (i == 1) would test 0.0; + // (i == 2) would just retest MIN_VALUE + testGetExponentCase(FpUtils.nextAfter(top, 0.0), + DoubleConsts.MIN_EXPONENT - 1); + + if( i >= 10) { + // create a bit mask with (i-1) 1's in the low order + // bits + long mask = ~((~0L)<<(i-1)); + double randFloat = Double.longBitsToDouble( // Exponent + Double.doubleToLongBits(top) | + // Significand + (rand.nextLong() & mask ) ) ; + + failures += testGetExponentCase(randFloat, + DoubleConsts.MIN_EXPONENT - 1); + } + } + } + + return failures; + } + + + /* ******************** nextAfter tests ****************************** */ + + static int testNextAfterCase(float start, double direction, float expected) { + int failures=0; + float minus_start = -start; + double minus_direction = -direction; + float minus_expected = -expected; + + failures+=Tests.test("Math.nextAfter(float,double)", start, direction, + Math.nextAfter(start, direction), expected); + failures+=Tests.test("Math.nextAfter(float,double)", minus_start, minus_direction, + Math.nextAfter(minus_start, minus_direction), minus_expected); + + failures+=Tests.test("StrictMath.nextAfter(float,double)", start, direction, + StrictMath.nextAfter(start, direction), expected); + failures+=Tests.test("StrictMath.nextAfter(float,double)", minus_start, minus_direction, + StrictMath.nextAfter(minus_start, minus_direction), minus_expected); + return failures; + } + + static int testNextAfterCase(double start, double direction, double expected) { + int failures=0; + + double minus_start = -start; + double minus_direction = -direction; + double minus_expected = -expected; + + failures+=Tests.test("Math.nextAfter(double,double)", start, direction, + Math.nextAfter(start, direction), expected); + failures+=Tests.test("Math.nextAfter(double,double)", minus_start, minus_direction, + Math.nextAfter(minus_start, minus_direction), minus_expected); + + failures+=Tests.test("StrictMath.nextAfter(double,double)", start, direction, + StrictMath.nextAfter(start, direction), expected); + failures+=Tests.test("StrictMath.nextAfter(double,double)", minus_start, minus_direction, + StrictMath.nextAfter(minus_start, minus_direction), minus_expected); + return failures; + } + + public static int testFloatNextAfter() { + int failures=0; + + /* + * Each row of the testCases matrix represents one test case + * for nexAfter; given the input of the first two columns, the + * result in the last column is expected. + */ + float [][] testCases = { + {NaNf, NaNf, NaNf}, + {NaNf, 0.0f, NaNf}, + {0.0f, NaNf, NaNf}, + {NaNf, infinityF, NaNf}, + {infinityF, NaNf, NaNf}, + + {infinityF, infinityF, infinityF}, + {infinityF, -infinityF, Float.MAX_VALUE}, + {infinityF, 0.0f, Float.MAX_VALUE}, + + {Float.MAX_VALUE, infinityF, infinityF}, + {Float.MAX_VALUE, -infinityF, Float_MAX_VALUEmm}, + {Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE}, + {Float.MAX_VALUE, 0.0f, Float_MAX_VALUEmm}, + + {Float_MAX_VALUEmm, Float.MAX_VALUE, Float.MAX_VALUE}, + {Float_MAX_VALUEmm, infinityF, Float.MAX_VALUE}, + {Float_MAX_VALUEmm, Float_MAX_VALUEmm, Float_MAX_VALUEmm}, + + {FloatConsts.MIN_NORMAL, infinityF, FloatConsts.MIN_NORMAL+ + Float.MIN_VALUE}, + {FloatConsts.MIN_NORMAL, -infinityF, Float_MAX_SUBNORMAL}, + {FloatConsts.MIN_NORMAL, 1.0f, FloatConsts.MIN_NORMAL+ + Float.MIN_VALUE}, + {FloatConsts.MIN_NORMAL, -1.0f, Float_MAX_SUBNORMAL}, + {FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL}, + + {Float_MAX_SUBNORMAL, FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL}, + {Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL}, + {Float_MAX_SUBNORMAL, 0.0f, Float_MAX_SUBNORMALmm}, + + {Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL}, + {Float_MAX_SUBNORMALmm, 0.0f, Float_MAX_SUBNORMALmm-Float.MIN_VALUE}, + {Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMALmm}, + + {Float.MIN_VALUE, 0.0f, 0.0f}, + {-Float.MIN_VALUE, 0.0f, -0.0f}, + {Float.MIN_VALUE, Float.MIN_VALUE, Float.MIN_VALUE}, + {Float.MIN_VALUE, 1.0f, 2*Float.MIN_VALUE}, + + // Make sure zero behavior is tested + {0.0f, 0.0f, 0.0f}, + {0.0f, -0.0f, -0.0f}, + {-0.0f, 0.0f, 0.0f}, + {-0.0f, -0.0f, -0.0f}, + {0.0f, infinityF, Float.MIN_VALUE}, + {0.0f, -infinityF, -Float.MIN_VALUE}, + {-0.0f, infinityF, Float.MIN_VALUE}, + {-0.0f, -infinityF, -Float.MIN_VALUE}, + {0.0f, Float.MIN_VALUE, Float.MIN_VALUE}, + {0.0f, -Float.MIN_VALUE, -Float.MIN_VALUE}, + {-0.0f, Float.MIN_VALUE, Float.MIN_VALUE}, + {-0.0f, -Float.MIN_VALUE, -Float.MIN_VALUE} + }; + + for(int i = 0; i < testCases.length; i++) { + failures += testNextAfterCase(testCases[i][0], testCases[i][1], + testCases[i][2]); + } + + return failures; + } + + public static int testDoubleNextAfter() { + int failures =0; + + /* + * Each row of the testCases matrix represents one test case + * for nexAfter; given the input of the first two columns, the + * result in the last column is expected. + */ + double [][] testCases = { + {NaNd, NaNd, NaNd}, + {NaNd, 0.0d, NaNd}, + {0.0d, NaNd, NaNd}, + {NaNd, infinityD, NaNd}, + {infinityD, NaNd, NaNd}, + + {infinityD, infinityD, infinityD}, + {infinityD, -infinityD, Double.MAX_VALUE}, + {infinityD, 0.0d, Double.MAX_VALUE}, + + {Double.MAX_VALUE, infinityD, infinityD}, + {Double.MAX_VALUE, -infinityD, Double_MAX_VALUEmm}, + {Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE}, + {Double.MAX_VALUE, 0.0d, Double_MAX_VALUEmm}, + + {Double_MAX_VALUEmm, Double.MAX_VALUE, Double.MAX_VALUE}, + {Double_MAX_VALUEmm, infinityD, Double.MAX_VALUE}, + {Double_MAX_VALUEmm, Double_MAX_VALUEmm, Double_MAX_VALUEmm}, + + {DoubleConsts.MIN_NORMAL, infinityD, DoubleConsts.MIN_NORMAL+ + Double.MIN_VALUE}, + {DoubleConsts.MIN_NORMAL, -infinityD, Double_MAX_SUBNORMAL}, + {DoubleConsts.MIN_NORMAL, 1.0f, DoubleConsts.MIN_NORMAL+ + Double.MIN_VALUE}, + {DoubleConsts.MIN_NORMAL, -1.0f, Double_MAX_SUBNORMAL}, + {DoubleConsts.MIN_NORMAL, DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL}, + + {Double_MAX_SUBNORMAL, DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL}, + {Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL}, + {Double_MAX_SUBNORMAL, 0.0d, Double_MAX_SUBNORMALmm}, + + {Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL}, + {Double_MAX_SUBNORMALmm, 0.0d, Double_MAX_SUBNORMALmm-Double.MIN_VALUE}, + {Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMALmm}, + + {Double.MIN_VALUE, 0.0d, 0.0d}, + {-Double.MIN_VALUE, 0.0d, -0.0d}, + {Double.MIN_VALUE, Double.MIN_VALUE, Double.MIN_VALUE}, + {Double.MIN_VALUE, 1.0f, 2*Double.MIN_VALUE}, + + // Make sure zero behavior is tested + {0.0d, 0.0d, 0.0d}, + {0.0d, -0.0d, -0.0d}, + {-0.0d, 0.0d, 0.0d}, + {-0.0d, -0.0d, -0.0d}, + {0.0d, infinityD, Double.MIN_VALUE}, + {0.0d, -infinityD, -Double.MIN_VALUE}, + {-0.0d, infinityD, Double.MIN_VALUE}, + {-0.0d, -infinityD, -Double.MIN_VALUE}, + {0.0d, Double.MIN_VALUE, Double.MIN_VALUE}, + {0.0d, -Double.MIN_VALUE, -Double.MIN_VALUE}, + {-0.0d, Double.MIN_VALUE, Double.MIN_VALUE}, + {-0.0d, -Double.MIN_VALUE, -Double.MIN_VALUE} + }; + + for(int i = 0; i < testCases.length; i++) { + failures += testNextAfterCase(testCases[i][0], testCases[i][1], + testCases[i][2]); + } + return failures; + } + + /* ******************** nextUp tests ********************************* */ + + public static int testFloatNextUp() { + int failures=0; + + /* + * Each row of testCases represents one test case for nextUp; + * the first column is the input and the second column is the + * expected result. + */ + float testCases [][] = { + {NaNf, NaNf}, + {-infinityF, -Float.MAX_VALUE}, + {-Float.MAX_VALUE, -Float_MAX_VALUEmm}, + {-FloatConsts.MIN_NORMAL, -Float_MAX_SUBNORMAL}, + {-Float_MAX_SUBNORMAL, -Float_MAX_SUBNORMALmm}, + {-Float.MIN_VALUE, -0.0f}, + {-0.0f, Float.MIN_VALUE}, + {+0.0f, Float.MIN_VALUE}, + {Float.MIN_VALUE, Float.MIN_VALUE*2}, + {Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL}, + {Float_MAX_SUBNORMAL, FloatConsts.MIN_NORMAL}, + {FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL+Float.MIN_VALUE}, + {Float_MAX_VALUEmm, Float.MAX_VALUE}, + {Float.MAX_VALUE, infinityF}, + {infinityF, infinityF} + }; + + for(int i = 0; i < testCases.length; i++) { + failures+=Tests.test("Math.nextUp(float)", + testCases[i][0], Math.nextUp(testCases[i][0]), testCases[i][1]); + + failures+=Tests.test("StrictMath.nextUp(float)", + testCases[i][0], StrictMath.nextUp(testCases[i][0]), testCases[i][1]); + } + + return failures; + } + + + public static int testDoubleNextUp() { + int failures=0; + + /* + * Each row of testCases represents one test case for nextUp; + * the first column is the input and the second column is the + * expected result. + */ + double testCases [][] = { + {NaNd, NaNd}, + {-infinityD, -Double.MAX_VALUE}, + {-Double.MAX_VALUE, -Double_MAX_VALUEmm}, + {-DoubleConsts.MIN_NORMAL, -Double_MAX_SUBNORMAL}, + {-Double_MAX_SUBNORMAL, -Double_MAX_SUBNORMALmm}, + {-Double.MIN_VALUE, -0.0d}, + {-0.0d, Double.MIN_VALUE}, + {+0.0d, Double.MIN_VALUE}, + {Double.MIN_VALUE, Double.MIN_VALUE*2}, + {Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL}, + {Double_MAX_SUBNORMAL, DoubleConsts.MIN_NORMAL}, + {DoubleConsts.MIN_NORMAL, DoubleConsts.MIN_NORMAL+Double.MIN_VALUE}, + {Double_MAX_VALUEmm, Double.MAX_VALUE}, + {Double.MAX_VALUE, infinityD}, + {infinityD, infinityD} + }; + + for(int i = 0; i < testCases.length; i++) { + failures+=Tests.test("Math.nextUp(double)", + testCases[i][0], Math.nextUp(testCases[i][0]), testCases[i][1]); + + failures+=Tests.test("StrictMath.nextUp(double)", + testCases[i][0], StrictMath.nextUp(testCases[i][0]), testCases[i][1]); + } + + return failures; + } + + /* ******************** nextDown tests ********************************* */ + + public static int testFloatNextDown() { + int failures=0; + + /* + * Each row of testCases represents one test case for nextDown; + * the first column is the input and the second column is the + * expected result. + */ + float testCases [][] = { + {NaNf, NaNf}, + {-infinityF, -infinityF}, + {-Float.MAX_VALUE, -infinityF}, + {-Float_MAX_VALUEmm, -Float.MAX_VALUE}, + {-Float_MAX_SUBNORMAL, -FloatConsts.MIN_NORMAL}, + {-Float_MAX_SUBNORMALmm, -Float_MAX_SUBNORMAL}, + {-0.0f, -Float.MIN_VALUE}, + {+0.0f, -Float.MIN_VALUE}, + {Float.MIN_VALUE, 0.0f}, + {Float.MIN_VALUE*2, Float.MIN_VALUE}, + {Float_MAX_SUBNORMAL, Float_MAX_SUBNORMALmm}, + {FloatConsts.MIN_NORMAL, Float_MAX_SUBNORMAL}, + {FloatConsts.MIN_NORMAL+ + Float.MIN_VALUE, FloatConsts.MIN_NORMAL}, + {Float.MAX_VALUE, Float_MAX_VALUEmm}, + {infinityF, Float.MAX_VALUE}, + }; + + for(int i = 0; i < testCases.length; i++) { + failures+=Tests.test("FpUtils.nextDown(float)", + testCases[i][0], FpUtils.nextDown(testCases[i][0]), testCases[i][1]); + } + + return failures; + } + + + public static int testDoubleNextDown() { + int failures=0; + + /* + * Each row of testCases represents one test case for nextDown; + * the first column is the input and the second column is the + * expected result. + */ + double testCases [][] = { + {NaNd, NaNd}, + {-infinityD, -infinityD}, + {-Double.MAX_VALUE, -infinityD}, + {-Double_MAX_VALUEmm, -Double.MAX_VALUE}, + {-Double_MAX_SUBNORMAL, -DoubleConsts.MIN_NORMAL}, + {-Double_MAX_SUBNORMALmm, -Double_MAX_SUBNORMAL}, + {-0.0d, -Double.MIN_VALUE}, + {+0.0d, -Double.MIN_VALUE}, + {Double.MIN_VALUE, 0.0d}, + {Double.MIN_VALUE*2, Double.MIN_VALUE}, + {Double_MAX_SUBNORMAL, Double_MAX_SUBNORMALmm}, + {DoubleConsts.MIN_NORMAL, Double_MAX_SUBNORMAL}, + {DoubleConsts.MIN_NORMAL+ + Double.MIN_VALUE, DoubleConsts.MIN_NORMAL}, + {Double.MAX_VALUE, Double_MAX_VALUEmm}, + {infinityD, Double.MAX_VALUE}, + }; + + for(int i = 0; i < testCases.length; i++) { + failures+=Tests.test("FpUtils.nextDown(double)", + testCases[i][0], FpUtils.nextDown(testCases[i][0]), testCases[i][1]); + } + + return failures; + } + + + /* ********************** boolean tests ****************************** */ + + /* + * Combined tests for boolean functions, isFinite, isInfinite, + * isNaN, isUnordered. + */ + + public static int testFloatBooleanMethods() { + int failures = 0; + + float testCases [] = { + NaNf, + -infinityF, + infinityF, + -Float.MAX_VALUE, + -3.0f, + -1.0f, + -FloatConsts.MIN_NORMAL, + -Float_MAX_SUBNORMALmm, + -Float_MAX_SUBNORMAL, + -Float.MIN_VALUE, + -0.0f, + +0.0f, + Float.MIN_VALUE, + Float_MAX_SUBNORMALmm, + Float_MAX_SUBNORMAL, + FloatConsts.MIN_NORMAL, + 1.0f, + 3.0f, + Float_MAX_VALUEmm, + Float.MAX_VALUE + }; + + for(int i = 0; i < testCases.length; i++) { + // isNaN + failures+=Tests.test("FpUtils.isNaN(float)", testCases[i], + FpUtils.isNaN(testCases[i]), (i ==0)); + + // isFinite + failures+=Tests.test("FpUtils.isFinite(float)", testCases[i], + FpUtils.isFinite(testCases[i]), (i >= 3)); + + // isInfinite + failures+=Tests.test("FpUtils.isInfinite(float)", testCases[i], + FpUtils.isInfinite(testCases[i]), (i==1 || i==2)); + + // isUnorderd + for(int j = 0; j < testCases.length; j++) { + failures+=Tests.test("FpUtils.isUnordered(float, float)", testCases[i],testCases[j], + FpUtils.isUnordered(testCases[i],testCases[j]), (i==0 || j==0)); + } + } + + return failures; + } + + public static int testDoubleBooleanMethods() { + int failures = 0; + boolean result = false; + + double testCases [] = { + NaNd, + -infinityD, + infinityD, + -Double.MAX_VALUE, + -3.0d, + -1.0d, + -DoubleConsts.MIN_NORMAL, + -Double_MAX_SUBNORMALmm, + -Double_MAX_SUBNORMAL, + -Double.MIN_VALUE, + -0.0d, + +0.0d, + Double.MIN_VALUE, + Double_MAX_SUBNORMALmm, + Double_MAX_SUBNORMAL, + DoubleConsts.MIN_NORMAL, + 1.0d, + 3.0d, + Double_MAX_VALUEmm, + Double.MAX_VALUE + }; + + for(int i = 0; i < testCases.length; i++) { + // isNaN + failures+=Tests.test("FpUtils.isNaN(double)", testCases[i], + FpUtils.isNaN(testCases[i]), (i ==0)); + + // isFinite + failures+=Tests.test("FpUtils.isFinite(double)", testCases[i], + FpUtils.isFinite(testCases[i]), (i >= 3)); + + // isInfinite + failures+=Tests.test("FpUtils.isInfinite(double)", testCases[i], + FpUtils.isInfinite(testCases[i]), (i==1 || i==2)); + + // isUnorderd + for(int j = 0; j < testCases.length; j++) { + failures+=Tests.test("FpUtils.isUnordered(double, double)", testCases[i],testCases[j], + FpUtils.isUnordered(testCases[i],testCases[j]), (i==0 || j==0)); + } + } + + return failures; + } + + /* ******************** copySign tests******************************** */ + + public static int testFloatCopySign() { + int failures = 0; + + // testCases[0] are logically positive numbers; + // testCases[1] are negative numbers. + float testCases [][] = { + {+0.0f, + Float.MIN_VALUE, + Float_MAX_SUBNORMALmm, + Float_MAX_SUBNORMAL, + FloatConsts.MIN_NORMAL, + 1.0f, + 3.0f, + Float_MAX_VALUEmm, + Float.MAX_VALUE, + infinityF, + }, + {-infinityF, + -Float.MAX_VALUE, + -3.0f, + -1.0f, + -FloatConsts.MIN_NORMAL, + -Float_MAX_SUBNORMALmm, + -Float_MAX_SUBNORMAL, + -Float.MIN_VALUE, + -0.0f} + }; + + float NaNs[] = {Float.intBitsToFloat(0x7fc00000), // "positive" NaN + Float.intBitsToFloat(0xFfc00000)}; // "negative" NaN + + // Tests shared between raw and non-raw versions + for(int i = 0; i < 2; i++) { + for(int j = 0; j < 2; j++) { + for(int m = 0; m < testCases[i].length; m++) { + for(int n = 0; n < testCases[j].length; n++) { + // copySign(magnitude, sign) + failures+=Tests.test("Math.copySign(float,float)", + testCases[i][m],testCases[j][n], + Math.copySign(testCases[i][m], testCases[j][n]), + (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) ); + + failures+=Tests.test("StrictMath.copySign(float,float)", + testCases[i][m],testCases[j][n], + StrictMath.copySign(testCases[i][m], testCases[j][n]), + (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) ); + } + } + } + } + + // For rawCopySign, NaN may effectively have either sign bit + // while for copySign NaNs are treated as if they always have + // a zero sign bit (i.e. as positive numbers) + for(int i = 0; i < 2; i++) { + for(int j = 0; j < NaNs.length; j++) { + for(int m = 0; m < testCases[i].length; m++) { + // copySign(magnitude, sign) + + failures += (Math.abs(Math.copySign(testCases[i][m], NaNs[j])) == + Math.abs(testCases[i][m])) ? 0:1; + + + failures+=Tests.test("StrictMath.copySign(float,float)", + testCases[i][m], NaNs[j], + StrictMath.copySign(testCases[i][m], NaNs[j]), + Math.abs(testCases[i][m]) ); + } + } + } + + return failures; + } + + public static int testDoubleCopySign() { + int failures = 0; + + // testCases[0] are logically positive numbers; + // testCases[1] are negative numbers. + double testCases [][] = { + {+0.0d, + Double.MIN_VALUE, + Double_MAX_SUBNORMALmm, + Double_MAX_SUBNORMAL, + DoubleConsts.MIN_NORMAL, + 1.0d, + 3.0d, + Double_MAX_VALUEmm, + Double.MAX_VALUE, + infinityD, + }, + {-infinityD, + -Double.MAX_VALUE, + -3.0d, + -1.0d, + -DoubleConsts.MIN_NORMAL, + -Double_MAX_SUBNORMALmm, + -Double_MAX_SUBNORMAL, + -Double.MIN_VALUE, + -0.0d} + }; + + double NaNs[] = {Double.longBitsToDouble(0x7ff8000000000000L), // "positive" NaN + Double.longBitsToDouble(0xfff8000000000000L), // "negative" NaN + Double.longBitsToDouble(0x7FF0000000000001L), + Double.longBitsToDouble(0xFFF0000000000001L), + Double.longBitsToDouble(0x7FF8555555555555L), + Double.longBitsToDouble(0xFFF8555555555555L), + Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), + Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), + Double.longBitsToDouble(0x7FFDeadBeef00000L), + Double.longBitsToDouble(0xFFFDeadBeef00000L), + Double.longBitsToDouble(0x7FFCafeBabe00000L), + Double.longBitsToDouble(0xFFFCafeBabe00000L)}; + + // Tests shared between Math and StrictMath versions + for(int i = 0; i < 2; i++) { + for(int j = 0; j < 2; j++) { + for(int m = 0; m < testCases[i].length; m++) { + for(int n = 0; n < testCases[j].length; n++) { + // copySign(magnitude, sign) + failures+=Tests.test("MathcopySign(double,double)", + testCases[i][m],testCases[j][n], + Math.copySign(testCases[i][m], testCases[j][n]), + (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) ); + + failures+=Tests.test("StrictMath.copySign(double,double)", + testCases[i][m],testCases[j][n], + StrictMath.copySign(testCases[i][m], testCases[j][n]), + (j==0?1.0f:-1.0f)*Math.abs(testCases[i][m]) ); + } + } + } + } + + // For Math.copySign, NaN may effectively have either sign bit + // while for StrictMath.copySign NaNs are treated as if they + // always have a zero sign bit (i.e. as positive numbers) + for(int i = 0; i < 2; i++) { + for(int j = 0; j < NaNs.length; j++) { + for(int m = 0; m < testCases[i].length; m++) { + // copySign(magnitude, sign) + + failures += (Math.abs(Math.copySign(testCases[i][m], NaNs[j])) == + Math.abs(testCases[i][m])) ? 0:1; + + + failures+=Tests.test("StrictMath.copySign(double,double)", + testCases[i][m], NaNs[j], + StrictMath.copySign(testCases[i][m], NaNs[j]), + Math.abs(testCases[i][m]) ); + } + } + } + + + return failures; + } + + /* ************************ scalb tests ******************************* */ + + static int testScalbCase(float value, int scale_factor, float expected) { + int failures=0; + + failures+=Tests.test("Math.scalb(float,int)", + value, scale_factor, + Math.scalb(value, scale_factor), expected); + + failures+=Tests.test("Math.scalb(float,int)", + -value, scale_factor, + Math.scalb(-value, scale_factor), -expected); + + failures+=Tests.test("StrictMath.scalb(float,int)", + value, scale_factor, + StrictMath.scalb(value, scale_factor), expected); + + failures+=Tests.test("StrictMath.scalb(float,int)", + -value, scale_factor, + StrictMath.scalb(-value, scale_factor), -expected); + return failures; + } + + public static int testFloatScalb() { + int failures=0; + int MAX_SCALE = FloatConsts.MAX_EXPONENT + -FloatConsts.MIN_EXPONENT + + FloatConsts.SIGNIFICAND_WIDTH + 1; + + + // Arguments x, where scalb(x,n) is x for any n. + float [] identityTestCases = {NaNf, + -0.0f, + +0.0f, + infinityF, + -infinityF + }; + + float [] subnormalTestCases = { + Float.MIN_VALUE, + 3.0f*Float.MIN_VALUE, + Float_MAX_SUBNORMALmm, + Float_MAX_SUBNORMAL + }; + + float [] someTestCases = { + Float.MIN_VALUE, + 3.0f*Float.MIN_VALUE, + Float_MAX_SUBNORMALmm, + Float_MAX_SUBNORMAL, + FloatConsts.MIN_NORMAL, + 1.0f, + 2.0f, + 3.0f, + (float)Math.PI, + Float_MAX_VALUEmm, + Float.MAX_VALUE + }; + + int [] oneMultiplyScalingFactors = { + FloatConsts.MIN_EXPONENT, + FloatConsts.MIN_EXPONENT+1, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + FloatConsts.MAX_EXPONENT-1, + FloatConsts.MAX_EXPONENT + }; + + int [] manyScalingFactors = { + Integer.MIN_VALUE, + Integer.MIN_VALUE+1, + -MAX_SCALE -1, + -MAX_SCALE, + -MAX_SCALE+1, + + 2*FloatConsts.MIN_EXPONENT-1, // -253 + 2*FloatConsts.MIN_EXPONENT, // -252 + 2*FloatConsts.MIN_EXPONENT+1, // -251 + + FpUtils.ilogb(Float.MIN_VALUE)-1, // -150 + FpUtils.ilogb(Float.MIN_VALUE), // -149 + -FloatConsts.MAX_EXPONENT, // -127 + FloatConsts.MIN_EXPONENT, // -126 + + -2, + -1, + 0, + 1, + 2, + + FloatConsts.MAX_EXPONENT-1, // 126 + FloatConsts.MAX_EXPONENT, // 127 + FloatConsts.MAX_EXPONENT+1, // 128 + + 2*FloatConsts.MAX_EXPONENT-1, // 253 + 2*FloatConsts.MAX_EXPONENT, // 254 + 2*FloatConsts.MAX_EXPONENT+1, // 255 + + MAX_SCALE-1, + MAX_SCALE, + MAX_SCALE+1, + Integer.MAX_VALUE-1, + Integer.MAX_VALUE + }; + + // Test cases where scaling is always a no-op + for(int i=0; i < identityTestCases.length; i++) { + for(int j=0; j < manyScalingFactors.length; j++) { + failures += testScalbCase(identityTestCases[i], + manyScalingFactors[j], + identityTestCases[i]); + } + } + + // Test cases where result is 0.0 or infinity due to magnitude + // of the scaling factor + for(int i=0; i < someTestCases.length; i++) { + for(int j=0; j < manyScalingFactors.length; j++) { + int scaleFactor = manyScalingFactors[j]; + if (Math.abs(scaleFactor) >= MAX_SCALE) { + float value = someTestCases[i]; + failures+=testScalbCase(value, + scaleFactor, + FpUtils.copySign( (scaleFactor>0?infinityF:0.0f), value) ); + } + } + } + + // Test cases that could be done with one floating-point + // multiply. + for(int i=0; i < someTestCases.length; i++) { + for(int j=0; j < oneMultiplyScalingFactors.length; j++) { + int scaleFactor = oneMultiplyScalingFactors[j]; + float value = someTestCases[i]; + + failures+=testScalbCase(value, + scaleFactor, + value*powerOfTwoF(scaleFactor)); + } + } + + // Create 2^MAX_EXPONENT + float twoToTheMaxExp = 1.0f; // 2^0 + for(int i = 0; i < FloatConsts.MAX_EXPONENT; i++) + twoToTheMaxExp *=2.0f; + + // Scale-up subnormal values until they all overflow + for(int i=0; i < subnormalTestCases.length; i++) { + float scale = 1.0f; // 2^j + float value = subnormalTestCases[i]; + + for(int j=FloatConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow + int scaleFactor = j; + + failures+=testScalbCase(value, + scaleFactor, + (FpUtils.ilogb(value) +j > FloatConsts.MAX_EXPONENT ) ? + FpUtils.copySign(infinityF, value) : // overflow + // calculate right answer + twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) ); + scale*=2.0f; + } + } + + // Scale down a large number until it underflows. By scaling + // down MAX_NORMALmm, the first subnormal result will be exact + // but the next one will round -- all those results can be + // checked by halving a separate value in the loop. Actually, + // we can keep halving and checking until the product is zero + // since: + // + // 1. If the scalb of MAX_VALUEmm is subnormal and *not* exact + // it will round *up* + // + // 2. When rounding first occurs in the expected product, it + // too rounds up, to 2^-MAX_EXPONENT. + // + // Halving expected after rounding happends to give the same + // result as the scalb operation. + float expected = Float_MAX_VALUEmm *0.5f; + for(int i = -1; i > -MAX_SCALE; i--) { + failures+=testScalbCase(Float_MAX_VALUEmm, i, expected); + + expected *= 0.5f; + } + + // Tricky rounding tests: + // Scale down a large number into subnormal range such that if + // scalb is being implemented with multiple floating-point + // multiplies, the value would round twice if the multiplies + // were done in the wrong order. + + float value = 0x8.0000bP-5f; + expected = 0x1.00001p-129f; + + for(int i = 0; i < 129; i++) { + failures+=testScalbCase(value, + -127-i, + expected); + value *=2.0f; + } + + return failures; + } + + static int testScalbCase(double value, int scale_factor, double expected) { + int failures=0; + + failures+=Tests.test("Math.scalb(double,int)", + value, scale_factor, + Math.scalb(value, scale_factor), expected); + + failures+=Tests.test("Math.scalb(double,int)", + -value, scale_factor, + Math.scalb(-value, scale_factor), -expected); + + failures+=Tests.test("StrictMath.scalb(double,int)", + value, scale_factor, + StrictMath.scalb(value, scale_factor), expected); + + failures+=Tests.test("StrictMath.scalb(double,int)", + -value, scale_factor, + StrictMath.scalb(-value, scale_factor), -expected); + + return failures; + } + + public static int testDoubleScalb() { + int failures=0; + int MAX_SCALE = DoubleConsts.MAX_EXPONENT + -DoubleConsts.MIN_EXPONENT + + DoubleConsts.SIGNIFICAND_WIDTH + 1; + + + // Arguments x, where scalb(x,n) is x for any n. + double [] identityTestCases = {NaNd, + -0.0, + +0.0, + infinityD, + }; + + double [] subnormalTestCases = { + Double.MIN_VALUE, + 3.0d*Double.MIN_VALUE, + Double_MAX_SUBNORMALmm, + Double_MAX_SUBNORMAL + }; + + double [] someTestCases = { + Double.MIN_VALUE, + 3.0d*Double.MIN_VALUE, + Double_MAX_SUBNORMALmm, + Double_MAX_SUBNORMAL, + DoubleConsts.MIN_NORMAL, + 1.0d, + 2.0d, + 3.0d, + Math.PI, + Double_MAX_VALUEmm, + Double.MAX_VALUE + }; + + int [] oneMultiplyScalingFactors = { + DoubleConsts.MIN_EXPONENT, + DoubleConsts.MIN_EXPONENT+1, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + DoubleConsts.MAX_EXPONENT-1, + DoubleConsts.MAX_EXPONENT + }; + + int [] manyScalingFactors = { + Integer.MIN_VALUE, + Integer.MIN_VALUE+1, + -MAX_SCALE -1, + -MAX_SCALE, + -MAX_SCALE+1, + + 2*DoubleConsts.MIN_EXPONENT-1, // -2045 + 2*DoubleConsts.MIN_EXPONENT, // -2044 + 2*DoubleConsts.MIN_EXPONENT+1, // -2043 + + FpUtils.ilogb(Double.MIN_VALUE)-1, // -1076 + FpUtils.ilogb(Double.MIN_VALUE), // -1075 + -DoubleConsts.MAX_EXPONENT, // -1023 + DoubleConsts.MIN_EXPONENT, // -1022 + + -2, + -1, + 0, + 1, + 2, + + DoubleConsts.MAX_EXPONENT-1, // 1022 + DoubleConsts.MAX_EXPONENT, // 1023 + DoubleConsts.MAX_EXPONENT+1, // 1024 + + 2*DoubleConsts.MAX_EXPONENT-1, // 2045 + 2*DoubleConsts.MAX_EXPONENT, // 2046 + 2*DoubleConsts.MAX_EXPONENT+1, // 2047 + + MAX_SCALE-1, + MAX_SCALE, + MAX_SCALE+1, + Integer.MAX_VALUE-1, + Integer.MAX_VALUE + }; + + // Test cases where scaling is always a no-op + for(int i=0; i < identityTestCases.length; i++) { + for(int j=0; j < manyScalingFactors.length; j++) { + failures += testScalbCase(identityTestCases[i], + manyScalingFactors[j], + identityTestCases[i]); + } + } + + // Test cases where result is 0.0 or infinity due to magnitude + // of the scaling factor + for(int i=0; i < someTestCases.length; i++) { + for(int j=0; j < manyScalingFactors.length; j++) { + int scaleFactor = manyScalingFactors[j]; + if (Math.abs(scaleFactor) >= MAX_SCALE) { + double value = someTestCases[i]; + failures+=testScalbCase(value, + scaleFactor, + FpUtils.copySign( (scaleFactor>0?infinityD:0.0), value) ); + } + } + } + + // Test cases that could be done with one floating-point + // multiply. + for(int i=0; i < someTestCases.length; i++) { + for(int j=0; j < oneMultiplyScalingFactors.length; j++) { + int scaleFactor = oneMultiplyScalingFactors[j]; + double value = someTestCases[i]; + + failures+=testScalbCase(value, + scaleFactor, + value*powerOfTwoD(scaleFactor)); + } + } + + // Create 2^MAX_EXPONENT + double twoToTheMaxExp = 1.0; // 2^0 + for(int i = 0; i < DoubleConsts.MAX_EXPONENT; i++) + twoToTheMaxExp *=2.0; + + // Scale-up subnormal values until they all overflow + for(int i=0; i < subnormalTestCases.length; i++) { + double scale = 1.0; // 2^j + double value = subnormalTestCases[i]; + + for(int j=DoubleConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow + int scaleFactor = j; + + failures+=testScalbCase(value, + scaleFactor, + (FpUtils.ilogb(value) +j > DoubleConsts.MAX_EXPONENT ) ? + FpUtils.copySign(infinityD, value) : // overflow + // calculate right answer + twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) ); + scale*=2.0; + } + } + + // Scale down a large number until it underflows. By scaling + // down MAX_NORMALmm, the first subnormal result will be exact + // but the next one will round -- all those results can be + // checked by halving a separate value in the loop. Actually, + // we can keep halving and checking until the product is zero + // since: + // + // 1. If the scalb of MAX_VALUEmm is subnormal and *not* exact + // it will round *up* + // + // 2. When rounding first occurs in the expected product, it + // too rounds up, to 2^-MAX_EXPONENT. + // + // Halving expected after rounding happends to give the same + // result as the scalb operation. + double expected = Double_MAX_VALUEmm *0.5f; + for(int i = -1; i > -MAX_SCALE; i--) { + failures+=testScalbCase(Double_MAX_VALUEmm, i, expected); + + expected *= 0.5; + } + + // Tricky rounding tests: + // Scale down a large number into subnormal range such that if + // scalb is being implemented with multiple floating-point + // multiplies, the value would round twice if the multiplies + // were done in the wrong order. + + double value = 0x1.000000000000bP-1; + expected = 0x0.2000000000001P-1022; + for(int i = 0; i < DoubleConsts.MAX_EXPONENT+2; i++) { + failures+=testScalbCase(value, + -1024-i, + expected); + value *=2.0; + } + + return failures; + } + + /* ************************* ulp tests ******************************* */ + + + /* + * Test Math.ulp and StrictMath.ulp with +d and -d. + */ + static int testUlpCase(float f, float expected) { + float minus_f = -f; + int failures=0; + + failures+=Tests.test("Math.ulp(float)", f, + Math.ulp(f), expected); + failures+=Tests.test("Math.ulp(float)", minus_f, + Math.ulp(minus_f), expected); + failures+=Tests.test("StrictMath.ulp(float)", f, + StrictMath.ulp(f), expected); + failures+=Tests.test("StrictMath.ulp(float)", minus_f, + StrictMath.ulp(minus_f), expected); + return failures; + } + + static int testUlpCase(double d, double expected) { + double minus_d = -d; + int failures=0; + + failures+=Tests.test("Math.ulp(double)", d, + Math.ulp(d), expected); + failures+=Tests.test("Math.ulp(double)", minus_d, + Math.ulp(minus_d), expected); + failures+=Tests.test("StrictMath.ulp(double)", d, + StrictMath.ulp(d), expected); + failures+=Tests.test("StrictMath.ulp(double)", minus_d, + StrictMath.ulp(minus_d), expected); + return failures; + } + + public static int testFloatUlp() { + int failures = 0; + float [] specialValues = {NaNf, + Float.POSITIVE_INFINITY, + +0.0f, + +1.0f, + +2.0f, + +16.0f, + +Float.MIN_VALUE, + +Float_MAX_SUBNORMAL, + +FloatConsts.MIN_NORMAL, + +Float.MAX_VALUE + }; + + float [] specialResults = {NaNf, + Float.POSITIVE_INFINITY, + Float.MIN_VALUE, + powerOfTwoF(-23), + powerOfTwoF(-22), + powerOfTwoF(-19), + Float.MIN_VALUE, + Float.MIN_VALUE, + Float.MIN_VALUE, + powerOfTwoF(104) + }; + + // Special value tests + for(int i = 0; i < specialValues.length; i++) { + failures += testUlpCase(specialValues[i], specialResults[i]); + } + + + // Normal exponent tests + for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) { + float expected; + + // Create power of two + float po2 = powerOfTwoF(i); + expected = FpUtils.scalb(1.0f, i - (FloatConsts.SIGNIFICAND_WIDTH-1)); + + failures += testUlpCase(po2, expected); + + // Generate some random bit patterns for the significand + for(int j = 0; j < 10; j++) { + int randSignif = rand.nextInt(); + float randFloat; + + randFloat = Float.intBitsToFloat( // Exponent + (Float.floatToIntBits(po2)& + (~FloatConsts.SIGNIF_BIT_MASK)) | + // Significand + (randSignif & + FloatConsts.SIGNIF_BIT_MASK) ); + + failures += testUlpCase(randFloat, expected); + } + + if (i > FloatConsts.MIN_EXPONENT) { + float po2minus = FpUtils.nextAfter(po2, + Float.NEGATIVE_INFINITY); + failures += testUlpCase(po2minus, expected/2.0f); + } + } + + // Subnormal tests + + /* + * Start with MIN_VALUE, left shift, test high value, low + * values, and random in between. + * + * Use nextAfter to calculate, high value of previous binade, + * loop count i will indicate how many random bits, if any are + * needed. + */ + + float top=Float.MIN_VALUE; + for( int i = 1; + i < FloatConsts.SIGNIFICAND_WIDTH; + i++, top *= 2.0f) { + + failures += testUlpCase(top, Float.MIN_VALUE); + + // Test largest value in next smaller binade + if (i >= 3) {// (i == 1) would test 0.0; + // (i == 2) would just retest MIN_VALUE + testUlpCase(FpUtils.nextAfter(top, 0.0f), + Float.MIN_VALUE); + + if( i >= 10) { + // create a bit mask with (i-1) 1's in the low order + // bits + int mask = ~((~0)<<(i-1)); + float randFloat = Float.intBitsToFloat( // Exponent + Float.floatToIntBits(top) | + // Significand + (rand.nextInt() & mask ) ) ; + + failures += testUlpCase(randFloat, Float.MIN_VALUE); + } + } + } + + return failures; + } + + public static int testDoubleUlp() { + int failures = 0; + double [] specialValues = {NaNd, + Double.POSITIVE_INFINITY, + +0.0d, + +1.0d, + +2.0d, + +16.0d, + +Double.MIN_VALUE, + +Double_MAX_SUBNORMAL, + +DoubleConsts.MIN_NORMAL, + +Double.MAX_VALUE + }; + + double [] specialResults = {NaNf, + Double.POSITIVE_INFINITY, + Double.MIN_VALUE, + powerOfTwoD(-52), + powerOfTwoD(-51), + powerOfTwoD(-48), + Double.MIN_VALUE, + Double.MIN_VALUE, + Double.MIN_VALUE, + powerOfTwoD(971) + }; + + // Special value tests + for(int i = 0; i < specialValues.length; i++) { + failures += testUlpCase(specialValues[i], specialResults[i]); + } + + + // Normal exponent tests + for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) { + double expected; + + // Create power of two + double po2 = powerOfTwoD(i); + expected = FpUtils.scalb(1.0, i - (DoubleConsts.SIGNIFICAND_WIDTH-1)); + + failures += testUlpCase(po2, expected); + + // Generate some random bit patterns for the significand + for(int j = 0; j < 10; j++) { + long randSignif = rand.nextLong(); + double randDouble; + + randDouble = Double.longBitsToDouble( // Exponent + (Double.doubleToLongBits(po2)& + (~DoubleConsts.SIGNIF_BIT_MASK)) | + // Significand + (randSignif & + DoubleConsts.SIGNIF_BIT_MASK) ); + + failures += testUlpCase(randDouble, expected); + } + + if (i > DoubleConsts.MIN_EXPONENT) { + double po2minus = FpUtils.nextAfter(po2, + Double.NEGATIVE_INFINITY); + failures += testUlpCase(po2minus, expected/2.0f); + } + } + + // Subnormal tests + + /* + * Start with MIN_VALUE, left shift, test high value, low + * values, and random in between. + * + * Use nextAfter to calculate, high value of previous binade, + * loop count i will indicate how many random bits, if any are + * needed. + */ + + double top=Double.MIN_VALUE; + for( int i = 1; + i < DoubleConsts.SIGNIFICAND_WIDTH; + i++, top *= 2.0f) { + + failures += testUlpCase(top, Double.MIN_VALUE); + + // Test largest value in next smaller binade + if (i >= 3) {// (i == 1) would test 0.0; + // (i == 2) would just retest MIN_VALUE + testUlpCase(FpUtils.nextAfter(top, 0.0f), + Double.MIN_VALUE); + + if( i >= 10) { + // create a bit mask with (i-1) 1's in the low order + // bits + int mask = ~((~0)<<(i-1)); + double randDouble = Double.longBitsToDouble( // Exponent + Double.doubleToLongBits(top) | + // Significand + (rand.nextLong() & mask ) ) ; + + failures += testUlpCase(randDouble, Double.MIN_VALUE); + } + } + } + + return failures; + } + + public static int testFloatSignum() { + int failures = 0; + float testCases [][] = { + {NaNf, NaNf}, + {-infinityF, -1.0f}, + {-Float.MAX_VALUE, -1.0f}, + {-FloatConsts.MIN_NORMAL, -1.0f}, + {-1.0f, -1.0f}, + {-2.0f, -1.0f}, + {-Float_MAX_SUBNORMAL, -1.0f}, + {-Float.MIN_VALUE, -1.0f}, + {-0.0f, -0.0f}, + {+0.0f, +0.0f}, + {Float.MIN_VALUE, 1.0f}, + {Float_MAX_SUBNORMALmm, 1.0f}, + {Float_MAX_SUBNORMAL, 1.0f}, + {FloatConsts.MIN_NORMAL, 1.0f}, + {1.0f, 1.0f}, + {2.0f, 1.0f}, + {Float_MAX_VALUEmm, 1.0f}, + {Float.MAX_VALUE, 1.0f}, + {infinityF, 1.0f} + }; + + for(int i = 0; i < testCases.length; i++) { + failures+=Tests.test("Math.signum(float)", + testCases[i][0], Math.signum(testCases[i][0]), testCases[i][1]); + failures+=Tests.test("StrictMath.signum(float)", + testCases[i][0], StrictMath.signum(testCases[i][0]), testCases[i][1]); + } + + return failures; + } + + public static int testDoubleSignum() { + int failures = 0; + double testCases [][] = { + {NaNd, NaNd}, + {-infinityD, -1.0}, + {-Double.MAX_VALUE, -1.0}, + {-DoubleConsts.MIN_NORMAL, -1.0}, + {-1.0, -1.0}, + {-2.0, -1.0}, + {-Double_MAX_SUBNORMAL, -1.0}, + {-Double.MIN_VALUE, -1.0d}, + {-0.0d, -0.0d}, + {+0.0d, +0.0d}, + {Double.MIN_VALUE, 1.0}, + {Double_MAX_SUBNORMALmm, 1.0}, + {Double_MAX_SUBNORMAL, 1.0}, + {DoubleConsts.MIN_NORMAL, 1.0}, + {1.0, 1.0}, + {2.0, 1.0}, + {Double_MAX_VALUEmm, 1.0}, + {Double.MAX_VALUE, 1.0}, + {infinityD, 1.0} + }; + + for(int i = 0; i < testCases.length; i++) { + failures+=Tests.test("Math.signum(double)", + testCases[i][0], Math.signum(testCases[i][0]), testCases[i][1]); + failures+=Tests.test("StrictMath.signum(double)", + testCases[i][0], StrictMath.signum(testCases[i][0]), testCases[i][1]); + } + + return failures; + } + + + public static void main(String argv[]) { + int failures = 0; + + failures += testFloatGetExponent(); + failures += testDoubleGetExponent(); + + failures += testFloatNextAfter(); + failures += testDoubleNextAfter(); + + failures += testFloatNextUp(); + failures += testDoubleNextUp(); + + failures += testFloatNextDown(); + failures += testDoubleNextDown(); + + failures += testFloatBooleanMethods(); + failures += testDoubleBooleanMethods(); + + failures += testFloatCopySign(); + failures += testDoubleCopySign(); + + failures += testFloatScalb(); + failures += testDoubleScalb(); + + failures += testFloatUlp(); + failures += testDoubleUlp(); + + failures += testFloatSignum(); + failures += testDoubleSignum(); + + if (failures > 0) { + System.err.println("Testing the recommended functions incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:29 2009 +++ new/test/java/lang/Math/Log10Tests.java Mon Jan 26 16:12:28 2009 @@ -0,0 +1,223 @@ +/* + * Copyright 2003 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 4074599 4939441 + * @summary Tests for {Math, StrictMath}.log10 + * @author Joseph D. Darcy + */ + +import sun.misc.FpUtils; +import sun.misc.DoubleConsts; + +public class Log10Tests { + private Log10Tests(){} + + static final double infinityD = Double.POSITIVE_INFINITY; + static final double NaNd = Double.NaN; + static final double LN_10 = StrictMath.log(10.0); + + // Initialize shared random number generator + static java.util.Random rand = new java.util.Random(0L); + + static int testLog10Case(double input, double expected) { + int failures=0; + + failures+=Tests.test("Math.log10(double)", input, + Math.log10(input), expected); + + failures+=Tests.test("StrictMath.log10(double)", input, + StrictMath.log10(input), expected); + + return failures; + } + + static int testLog10() { + int failures = 0; + + double [][] testCases = { + {Double.NaN, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, + {Double.NEGATIVE_INFINITY, NaNd}, + {-8.0, NaNd}, + {-1.0, NaNd}, + {-DoubleConsts.MIN_NORMAL, NaNd}, + {-Double.MIN_VALUE, NaNd}, + {-0.0, -infinityD}, + {+0.0, -infinityD}, + {+1.0, 0.0}, + {Double.POSITIVE_INFINITY, infinityD}, + }; + + // Test special cases + for(int i = 0; i < testCases.length; i++) { + failures += testLog10Case(testCases[i][0], + testCases[i][1]); + } + + // Test log10(10^n) == n for integer n; 10^n, n < 0 is not + // exactly representable as a floating-point value -- up to + // 10^22 can be represented exactly + double testCase = 1.0; + for(int i = 0; i < 23; i++) { + failures += testLog10Case(testCase, i); + testCase *= 10.0; + } + + // Test for gross inaccuracy by comparing to log; should be + // within a few ulps of log(x)/log(10) + for(int i = 0; i < 10000; i++) { + double input = Double.longBitsToDouble(rand.nextLong()); + if(! FpUtils.isFinite(input)) + continue; // avoid testing NaN and infinite values + else { + input = Math.abs(input); + + double expected = StrictMath.log(input)/LN_10; + if( ! FpUtils.isFinite(expected)) + continue; // if log(input) overflowed, try again + else { + double result; + + if( Math.abs(((result=Math.log10(input)) - expected)/Math.ulp(expected)) > 3) { + failures++; + System.err.println("For input " + input + + ", Math.log10 was more than 3 ulps different from " + + "log(input)/log(10): log10(input) = " + result + + "\tlog(input)/log(10) = " + expected); + } + + if( Math.abs(((result=StrictMath.log10(input)) - expected)/Math.ulp(expected)) > 3) { + failures++; + System.err.println("For input " + input + + ", StrictMath.log10 was more than 3 ulps different from " + + "log(input)/log(10): log10(input) = " + result + + "\tlog(input)/log(10) = " + expected); + } + + + } + } + } + + // Test for accuracy and monotonicity near log10(1.0). From + // the Taylor expansion of log, + // log10(1+z) ~= (z -(z^2)/2)/LN_10; + { + double neighbors[] = new double[40]; + double neighborsStrict[] = new double[40]; + double z = Double.NaN; + + // Test inputs greater than 1.0. + neighbors[0] = Math.log10(1.0); + neighborsStrict[0] = StrictMath.log10(1.0); + + double input[] = new double[40]; + int half = input.length/2; + + + // Initialize input to the 40 consecutive double values + // "centered" at 1.0. + double up = Double.NaN; + double down = Double.NaN; + for(int i = 0; i < half; i++) { + if (i == 0) { + input[half] = 1.0; + up = FpUtils.nextUp(1.0); + down = FpUtils.nextDown(1.0); + } else { + input[half + i] = up; + input[half - i] = down; + up = FpUtils.nextUp(up); + down = FpUtils.nextDown(down); + } + } + input[0] = FpUtils.nextDown(input[1]); + + for(int i = 0; i < neighbors.length; i++) { + neighbors[i] = Math.log10(input[i]); + neighborsStrict[i] = StrictMath.log10(input[i]); + + // Test accuracy. + z = input[i] - 1.0; + double expected = (z - (z*z)*0.5)/LN_10; + if ( Math.abs(neighbors[i] - expected ) > 3*Math.ulp(expected) ) { + failures++; + System.err.println("For input near 1.0 " + input[i] + + ", Math.log10(1+z) was more than 3 ulps different from " + + "(z-(z^2)/2)/ln(10): log10(input) = " + neighbors[i] + + "\texpected about = " + expected); + } + + if ( Math.abs(neighborsStrict[i] - expected ) > 3*Math.ulp(expected) ) { + failures++; + System.err.println("For input near 1.0 " + input[i] + + ", StrictMath.log10(1+z) was more than 3 ulps different from " + + "(z-(z^2)/2)/ln(10): log10(input) = " + neighborsStrict[i] + + "\texpected about = " + expected); + } + + // Test monotonicity + if( i > 0) { + if( neighbors[i-1] > neighbors[i] ) { + failures++; + System.err.println("Monotonicity failure for Math.log10 at " + input[i] + + " and prior value."); + } + + if( neighborsStrict[i-1] > neighborsStrict[i] ) { + failures++; + System.err.println("Monotonicity failure for StrictMath.log10 at " + input[i] + + " and prior value."); + } + } + } + + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += testLog10(); + + if (failures > 0) { + System.err.println("Testing log10 incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } + +} --- /dev/null Mon Jan 26 16:12:31 2009 +++ new/test/java/lang/Math/Log1pTests.java Mon Jan 26 16:12:30 2009 @@ -0,0 +1,206 @@ +/* + * Copyright 2003 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 4851638 4939441 + * @summary Tests for {Math, StrictMath}.log1p + * @author Joseph D. Darcy + */ + +import sun.misc.DoubleConsts; +import sun.misc.FpUtils; + +public class Log1pTests { + private Log1pTests(){} + + static final double infinityD = Double.POSITIVE_INFINITY; + static final double NaNd = Double.NaN; + + /** + * Formulation taken from HP-15C Advanced Functions Handbook, part + * number HP 0015-90011, p 181. This is accurate to a few ulps. + */ + static double hp15cLogp(double x) { + double u = 1.0 + x; + return (u==1.0? x : StrictMath.log(u)*x/(u-1) ); + } + + /* + * The Taylor expansion of ln(1 + x) for -1 < x <= 1 is: + * + * x - x^2/2 + x^3/3 - ... -(-x^j)/j + * + * Therefore, for small values of x, log1p(x) ~= x. For large + * values of x, log1p(x) ~= log(x). + * + * Also x/(x+1) < ln(1+x) < x + */ + + static int testLog1p() { + int failures = 0; + + double [][] testCases = { + {Double.NaN, NaNd}, + {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, + {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, + {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, + {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, + {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, + {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, + {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, + {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, + {Double.NEGATIVE_INFINITY, NaNd}, + {-8.0, NaNd}, + {-1.0, -infinityD}, + {-0.0, -0.0}, + {+0.0, +0.0}, + {infinityD, infinityD}, + }; + + // Test special cases + for(int i = 0; i < testCases.length; i++) { + failures += testLog1pCaseWithUlpDiff(testCases[i][0], + testCases[i][1], 0); + } + + // For |x| < 2^-54 log1p(x) ~= x + for(int i = DoubleConsts.MIN_SUB_EXPONENT; i <= -54; i++) { + double d = FpUtils.scalb(2, i); + failures += testLog1pCase(d, d); + failures += testLog1pCase(-d, -d); + } + + // For x > 2^53 log1p(x) ~= log(x) + for(int i = 53; i <= DoubleConsts.MAX_EXPONENT; i++) { + double d = FpUtils.scalb(2, i); + failures += testLog1pCaseWithUlpDiff(d, StrictMath.log(d), 2.001); + } + + // Construct random values with exponents ranging from -53 to + // 52 and compare against HP-15C formula. + java.util.Random rand = new java.util.Random(); + for(int i = 0; i < 1000; i++) { + double d = rand.nextDouble(); + + d = FpUtils.scalb(d, -53 - FpUtils.ilogb(d)); + + for(int j = -53; j <= 52; j++) { + failures += testLog1pCaseWithUlpDiff(d, hp15cLogp(d), 5); + + d *= 2.0; // increase exponent by 1 + } + } + + // Test for monotonicity failures near values y-1 where y ~= + // e^x. Test two numbers before and two numbers after each + // chosen value; i.e. + // + // pcNeighbors[] = + // {nextDown(nextDown(pc)), + // nextDown(pc), + // pc, + // nextUp(pc), + // nextUp(nextUp(pc))} + // + // and we test that log1p(pcNeighbors[i]) <= log1p(pcNeighbors[i+1]) + { + double pcNeighbors[] = new double[5]; + double pcNeighborsLog1p[] = new double[5]; + double pcNeighborsStrictLog1p[] = new double[5]; + + for(int i = -36; i <= 36; i++) { + double pc = StrictMath.pow(Math.E, i) - 1; + + pcNeighbors[2] = pc; + pcNeighbors[1] = FpUtils.nextDown(pc); + pcNeighbors[0] = FpUtils.nextDown(pcNeighbors[1]); + pcNeighbors[3] = FpUtils.nextUp(pc); + pcNeighbors[4] = FpUtils.nextUp(pcNeighbors[3]); + + for(int j = 0; j < pcNeighbors.length; j++) { + pcNeighborsLog1p[j] = Math.log1p(pcNeighbors[j]); + pcNeighborsStrictLog1p[j] = StrictMath.log1p(pcNeighbors[j]); + } + + for(int j = 0; j < pcNeighborsLog1p.length-1; j++) { + if(pcNeighborsLog1p[j] > pcNeighborsLog1p[j+1] ) { + failures++; + System.err.println("Monotonicity failure for Math.log1p on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsLog1p[j] + " and " + + pcNeighborsLog1p[j+1] ); + } + + if(pcNeighborsStrictLog1p[j] > pcNeighborsStrictLog1p[j+1] ) { + failures++; + System.err.println("Monotonicity failure for StrictMath.log1p on " + + pcNeighbors[j] + " and " + + pcNeighbors[j+1] + "\n\treturned " + + pcNeighborsStrictLog1p[j] + " and " + + pcNeighborsStrictLog1p[j+1] ); + } + + + } + + } + } + + return failures; + } + + public static int testLog1pCase(double input, + double expected) { + return testLog1pCaseWithUlpDiff(input, expected, 1); + } + + public static int testLog1pCaseWithUlpDiff(double input, + double expected, + double ulps) { + int failures = 0; + failures += Tests.testUlpDiff("Math.lop1p(double", + input, Math.log1p(input), + expected, ulps); + failures += Tests.testUlpDiff("StrictMath.log1p(double", + input, StrictMath.log1p(input), + expected, ulps); + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += testLog1p(); + + if (failures > 0) { + System.err.println("Testing log1p incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } + +} --- /dev/null Mon Jan 26 16:12:34 2009 +++ new/test/java/lang/Math/MinMax.java Mon Jan 26 16:12:33 2009 @@ -0,0 +1,124 @@ +/* + * Copyright 1997 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 4010528 4010529 + @summary Math.min and Math.max should treat negative zero as strictly + less than positive zero + */ + + +public class MinMax { + + + static void go(String what, float result, float correctResult) { + String v = what + ": got " + result + ", expected " + correctResult; + if (!(Float.toString(result).equals(Float.toString(correctResult)))) + throw new RuntimeException(v); + System.err.println(v); + } + + static void go(String what, double result, double correctResult) { + String v = what + ": got " + result + ", expected " + correctResult; + if (!(Double.toString(result).equals(Double.toString(correctResult)))) + throw new RuntimeException(v); + System.err.println(v); + } + + + public static void main(String[] args) { + + float fnz = -0.0f; + float fpz = +0.0f; + + go("Math.min(fnz, fnz)", Math.min(fnz, fnz), fnz); + go("Math.min(fnz, fpz)", Math.min(fnz, fpz), fnz); + go("Math.min(fpz, fnz)", Math.min(fpz, fnz), fnz); + go("Math.min(fpz, fpz)", Math.min(fpz, fpz), fpz); + + go("Math.min(-1.0f, fnz)", Math.min(-1.0f, fnz), -1.0f); + go("Math.min(-1.0f, fpz)", Math.min(-1.0f, fpz), -1.0f); + go("Math.min(+1.0f, fnz)", Math.min(+1.0f, fnz), fnz); + go("Math.min(+1.0f, fpz)", Math.min(+1.0f, fpz), fpz); + go("Math.min(-1.0f, +1.0f)", Math.min(-1.0f, +1.0f), -1.0f); + go("Math.min(fnz, -1.0f)", Math.min(fnz, -1.0f), -1.0f); + go("Math.min(fpz, -1.0f)", Math.min(fpz, -1.0f), -1.0f); + go("Math.min(fnz, +1.0f)", Math.min(fnz, +1.0f), fnz); + go("Math.min(fpz, +1.0f)", Math.min(fpz, +1.0f), fpz); + go("Math.min(+1.0f, -1.0f)", Math.min(+1.0f, -1.0f), -1.0f); + + go("Math.max(fnz, fnz)", Math.max(fnz, fnz), fnz); + go("Math.max(fnz, fpz)", Math.max(fnz, fpz), fpz); + go("Math.max(fpz, fnz)", Math.max(fpz, fnz), fpz); + go("Math.max(fpz, fpz)", Math.max(fpz, fpz), fpz); + + go("Math.max(-1.0f, fnz)", Math.max(-1.0f, fnz), fnz); + go("Math.max(-1.0f, fpz)", Math.max(-1.0f, fpz), fpz); + go("Math.max(+1.0f, fnz)", Math.max(+1.0f, fnz), +1.0f); + go("Math.max(+1.0f, fpz)", Math.max(+1.0f, fpz), +1.0f); + go("Math.max(-1.0f, +1.0f)", Math.max(-1.0f, +1.0f), +1.0f); + go("Math.max(fnz, -1.0f)", Math.max(fnz, -1.0f), fnz); + go("Math.max(fpz, -1.0f)", Math.max(fpz, -1.0f), fpz); + go("Math.max(fnz, +1.0f)", Math.max(fnz, +1.0f), +1.0f); + go("Math.max(fpz, +1.0f)", Math.max(fpz, +1.0f), +1.0f); + go("Math.max(+1.0f, -1.0f)", Math.max(+1.0f, -1.0f), +1.0f); + + + double dnz = -0.0d; + double dpz = +0.0d; + + go("Math.min(dnz, dnz)", Math.min(dnz, dnz), dnz); + go("Math.min(dnz, dpz)", Math.min(dnz, dpz), dnz); + go("Math.min(dpz, dnz)", Math.min(dpz, dnz), dnz); + go("Math.min(dpz, dpz)", Math.min(dpz, dpz), dpz); + + go("Math.min(-1.0d, dnz)", Math.min(-1.0d, dnz), -1.0d); + go("Math.min(-1.0d, dpz)", Math.min(-1.0d, dpz), -1.0d); + go("Math.min(+1.0d, dnz)", Math.min(+1.0d, dnz), dnz); + go("Math.min(+1.0d, dpz)", Math.min(+1.0d, dpz), dpz); + go("Math.min(-1.0d, +1.0d)", Math.min(-1.0d, +1.0d), -1.0d); + go("Math.min(dnz, -1.0d)", Math.min(dnz, -1.0d), -1.0d); + go("Math.min(dpz, -1.0d)", Math.min(dpz, -1.0d), -1.0d); + go("Math.min(dnz, +1.0d)", Math.min(dnz, +1.0d), dnz); + go("Math.min(dpz, +1.0d)", Math.min(dpz, +1.0d), dpz); + go("Math.min(+1.0d, -1.0d)", Math.min(+1.0d, -1.0d), -1.0d); + + go("Math.max(dnz, dnz)", Math.max(dnz, dnz), dnz); + go("Math.max(dnz, dpz)", Math.max(dnz, dpz), dpz); + go("Math.max(dpz, dnz)", Math.max(dpz, dnz), dpz); + go("Math.max(dpz, dpz)", Math.max(dpz, dpz), dpz); + + go("Math.max(-1.0d, dnz)", Math.max(-1.0d, dnz), dnz); + go("Math.max(-1.0d, dpz)", Math.max(-1.0d, dpz), dpz); + go("Math.max(+1.0d, dnz)", Math.max(+1.0d, dnz), +1.0d); + go("Math.max(+1.0d, dpz)", Math.max(+1.0d, dpz), +1.0d); + go("Math.max(-1.0d, +1.0d)", Math.max(-1.0d, +1.0d), +1.0d); + go("Math.max(dnz, -1.0d)", Math.max(dnz, -1.0d), dnz); + go("Math.max(dpz, -1.0d)", Math.max(dpz, -1.0d), dpz); + go("Math.max(dnz, +1.0d)", Math.max(dnz, +1.0d), +1.0d); + go("Math.max(dpz, +1.0d)", Math.max(dpz, +1.0d), +1.0d); + go("Math.max(+1.0d, -1.0d)", Math.max(+1.0d, -1.0d), +1.0d); + + } + +} --- /dev/null Mon Jan 26 16:12:36 2009 +++ new/test/java/lang/Math/PowTests.java Mon Jan 26 16:12:35 2009 @@ -0,0 +1,301 @@ +/* + * 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 4984407 5033578 + * @summary Tests for {Math, StrictMath}.pow + * @compile -source 1.5 PowTests.java + * @run main PowTests + * @author Joseph D. Darcy + */ + +public class PowTests { + private PowTests(){} + + static final double infinityD = Double.POSITIVE_INFINITY; + + static int testPowCase(double input1, double input2, double expected) { + int failures = 0; + failures += Tests.test("StrictMath.pow(double, double)", input1, input2, + StrictMath.pow(input1, input2), expected); + failures += Tests.test("Math.pow(double, double)", input1, input2, + Math.pow(input1, input2), expected); + return failures; + } + + + static int testStrictPowCase(double input1, double input2, double expected) { + int failures = 0; + failures += Tests.test("StrictMath.pow(double, double)", input1, input2, + StrictMath.pow(input1, input2), expected); + return failures; + } + + static int testNonstrictPowCase(double input1, double input2, double expected) { + int failures = 0; + failures += Tests.test("Math.pow(double, double)", input1, input2, + Math.pow(input1, input2), expected); + return failures; + } + + /* + * Test for bad negation implementation. + */ + static int testPow() { + int failures = 0; + + double [][] testCases = { + {-0.0, 3.0, -0.0}, + {-0.0, 4.0, 0.0}, + {-infinityD, -3.0, -0.0}, + {-infinityD, -4.0, 0.0}, + }; + + for (double[] testCase : testCases) { + failures+=testPowCase(testCase[0], testCase[1], testCase[2]); + } + + return failures; + } + + /* + * Test cross-product of different kinds of arguments. + */ + static int testCrossProduct() { + int failures = 0; + + double testData[] = { + Double.NEGATIVE_INFINITY, +/* > -oo */ -Double.MAX_VALUE, +/**/ (double)Long.MIN_VALUE, +/**/ (double) -((1L<<53)+2L), +/**/ (double) -((1L<<53)), +/**/ (double) -((1L<<53)-1L), +/**/ -((double)Integer.MAX_VALUE + 4.0), +/**/ (double)Integer.MIN_VALUE - 1.0, +/**/ (double)Integer.MIN_VALUE, +/**/ (double)Integer.MIN_VALUE + 1.0, +/**/ -Math.PI, +/**/ -3.0, +/**/ -Math.E, +/**/ -2.0, +/**/ -1.0000000000000004, +/* < -1.0 */ -1.0000000000000002, // nextAfter(-1.0, -oo) + -1.0, +/* > -1.0 */ -0.9999999999999999, // nextAfter(-1.0, +oo) +/* > -1.0 */ -0.9999999999999998, +/**/ -0.5, +/**/ -1.0/3.0, +/* < 0.0 */ -Double.MIN_VALUE, + -0.0, + +0.0, +/* > 0.0 */ +Double.MIN_VALUE, +/**/ +1.0/3.0, +/**/ +0.5, +/**/ +0.9999999999999998, +/* < +1.0 */ +0.9999999999999999, // nextAfter(-1.0, +oo) + +1.0, +/* > 1.0 */ +1.0000000000000002, // nextAfter(+1.0, +oo) +/**/ +1.0000000000000004, +/**/ +2.0, +/**/ +Math.E, +/**/ +3.0, +/**/ +Math.PI, +/**/ -(double)Integer.MIN_VALUE - 1.0, +/**/ -(double)Integer.MIN_VALUE, +/**/ -(double)Integer.MIN_VALUE + 1.0, +/**/ (double)Integer.MAX_VALUE + 4.0, +/**/ (double) ((1L<<53)-1L), +/**/ (double) ((1L<<53)), +/**/ (double) ((1L<<53)+2L), +/**/ -(double)Long.MIN_VALUE, +/* < oo */ Double.MAX_VALUE, + Double.POSITIVE_INFINITY, + Double.NaN + }; + + double NaN = Double.NaN; + for(double x: testData) { + for(double y: testData) { + boolean testPass = false; + double expected=NaN; + double actual; + + // First, switch on y + if( Double.isNaN(y)) { + expected = NaN; + } else if (y == 0.0) { + expected = 1.0; + } else if (Double.isInfinite(y) ) { + if(y > 0) { // x ^ (+oo) + if (Math.abs(x) > 1.0) { + expected = Double.POSITIVE_INFINITY; + } else if (Math.abs(x) == 1.0) { + expected = NaN; + } else if (Math.abs(x) < 1.0) { + expected = +0.0; + } else { // x is NaN + assert Double.isNaN(x); + expected = NaN; + } + } else { // x ^ (-oo) + if (Math.abs(x) > 1.0) { + expected = +0.0; + } else if (Math.abs(x) == 1.0) { + expected = NaN; + } else if (Math.abs(x) < 1.0) { + expected = Double.POSITIVE_INFINITY; + } else { // x is NaN + assert Double.isNaN(x); + expected = NaN; + } + } /* end Double.isInfinite(y) */ + } else if (y == 1.0) { + expected = x; + } else if (Double.isNaN(x)) { // Now start switching on x + assert y != 0.0; + expected = NaN; + } else if (x == Double.NEGATIVE_INFINITY) { + expected = (y < 0.0) ? f2(y) :f1(y); + } else if (x == Double.POSITIVE_INFINITY) { + expected = (y < 0.0) ? +0.0 : Double.POSITIVE_INFINITY; + } else if (equivalent(x, +0.0)) { + assert y != 0.0; + expected = (y < 0.0) ? Double.POSITIVE_INFINITY: +0.0; + } else if (equivalent(x, -0.0)) { + assert y != 0.0; + expected = (y < 0.0) ? f1(y): f2(y); + } else if( x < 0.0) { + assert y != 0.0; + failures += testStrictPowCase(x, y, f3(x, y)); + failures += testNonstrictPowCase(x, y, f3ns(x, y)); + continue; + } else { + // go to next iteration + expected = NaN; + continue; + } + + failures += testPowCase(x, y, expected); + } // y + } // x + return failures; + } + + static boolean equivalent(double a, double b) { + return Double.compare(a, b) == 0; + } + + static double f1(double y) { + return (intClassify(y) == 1)? + Double.NEGATIVE_INFINITY: + Double.POSITIVE_INFINITY; + } + + + static double f2(double y) { + return (intClassify(y) == 1)?-0.0:0.0; + } + + static double f3(double x, double y) { + switch( intClassify(y) ) { + case 0: + return StrictMath.pow(Math.abs(x), y); + // break; + + case 1: + return -StrictMath.pow(Math.abs(x), y); + // break; + + case -1: + return Double.NaN; + // break; + + default: + throw new AssertionError("Bad classification."); + // break; + } + } + + static double f3ns(double x, double y) { + switch( intClassify(y) ) { + case 0: + return Math.pow(Math.abs(x), y); + // break; + + case 1: + return -Math.pow(Math.abs(x), y); + // break; + + case -1: + return Double.NaN; + // break; + + default: + throw new AssertionError("Bad classification."); + // break; + } + } + + static boolean isFinite(double a) { + return (0.0*a == 0); + } + + /** + * Return classification of argument: -1 for non-integers, 0 for + * even integers, 1 for odd integers. + */ + static int intClassify(double a) { + if(!isFinite(a) || // NaNs and infinities + (a != Math.floor(a) )) { // only integers are fixed-points of floor + return -1; + } + else { + // Determine if argument is an odd or even integer. + + a = StrictMath.abs(a); // absolute value doesn't affect odd/even + + if(a+1.0 == a) { // a > maximum odd floating-point integer + return 0; // Large integers are all even + } + else { // Convert double -> long and look at low-order bit + long ell = (long) a; + return ((ell & 0x1L) == (long)1)?1:0; + } + } + } + + public static void main(String [] argv) { + int failures = 0; + + failures += testPow(); + failures += testCrossProduct(); + + if (failures > 0) { + System.err.println("Testing pow incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:38 2009 +++ new/test/java/lang/Math/Rint.java Mon Jan 26 16:12:37 2009 @@ -0,0 +1,122 @@ +/* + * Copyright 1998-2003 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 4101566 4831589 + * @summary Check for correct implementation of Math.rint(double) + * + */ + +import sun.misc.FpUtils; +import sun.misc.DoubleConsts; + +public class Rint { + + static int testRintCase(double input, double expected) { + int failures = 0; + double result; + failures += Tests.test("Math.rint", input, Math.rint(input), expected); + failures += Tests.test("Math.rint", -input, Math.rint(-input), -expected); + failures += Tests.test("StrictMath.rint", + input, StrictMath.rint(input), expected); + failures += Tests.test("StrictMath.rint", -input, + StrictMath.rint(-input), -expected); + return failures; + } + + + public static void main(String args[]) { + int failures = 0; + double twoToThe52 = FpUtils.scalb(1.0, 52); // 2^52 + + double [][] testCases = { + {0.0, 0.0}, + {Double.MIN_VALUE, 0.0}, + {FpUtils.nextDown(DoubleConsts.MIN_NORMAL), 0.0}, + {DoubleConsts.MIN_NORMAL, 0.0}, + + {0.2, 0.0}, + + {FpUtils.nextDown(0.5), 0.0}, + { 0.5, 0.0}, + { FpUtils.nextUp(0.5), 1.0}, + + {0.7, 1.0}, + {FpUtils.nextDown(1.0), 1.0}, + { 1.0, 1.0}, + { FpUtils.nextUp(1.0), 1.0}, + + {FpUtils.nextDown(1.5), 1.0}, + { 1.5, 2.0}, + { FpUtils.nextUp(1.5), 2.0}, + + {4.2, 4.0}, + {4.5, 4.0}, + {4.7, 5.0}, + + {7.5, 8.0}, + {7.2, 7.0}, + {7.7, 8.0}, + + {150000.75, 150001.0}, + {300000.5, 300000.0}, + {FpUtils.nextUp(300000.5), 300001.0}, + {FpUtils.nextDown(300000.75), 300001.0}, + {300000.75, 300001.0}, + {FpUtils.nextUp(300000.75), 300001.0}, + {300000.99, 300001.0}, + {262144.75, 262145.0}, //(2^18 ) + 0.75 + {499998.75, 499999.0}, + {524287.75, 524288.0}, //(2^19 -1) + 0.75 + {524288.75, 524289.0}, + + {FpUtils.nextDown(twoToThe52), twoToThe52}, + {twoToThe52, twoToThe52}, + {FpUtils.nextUp(twoToThe52), FpUtils.nextUp(twoToThe52)}, + + {Double.MAX_VALUE, Double.MAX_VALUE}, + {Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY}, + {Double.NaN, Double.NaN} + + }; + + + for(int i = 0; i < testCases.length; i++) { + failures += testRintCase(testCases[i][0], testCases[i][1]); + } + + // Test values throughout exponent range + for(double d = Double.MIN_VALUE; + d < Double.POSITIVE_INFINITY; d *= 2) { + failures += testRintCase(d, ((d<=0.5)?0.0:d)); + } + + if (failures > 0) { + System.err.println("Testing {Math, StrictMath}.rint incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } + +} --- /dev/null Mon Jan 26 16:12:41 2009 +++ new/test/java/lang/Math/TanTests.java Mon Jan 26 16:12:39 2009 @@ -0,0 +1,189 @@ +/* + * 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 5033578 + * @summary Tests for {Math, StrictMath}.tan + * @compile -source 1.5 TanTests.java + * @run main TanTests + * @author Joseph D. Darcy + */ + +public class TanTests { + private TanTests(){} + + static int testTanCase(double input, double expected, double ulps) { + int failures = 0; + failures += Tests.testUlpDiff("StrictMath.tan(double, double)", input, + StrictMath.tan(input), expected, ulps); + failures += Tests.testUlpDiff("Math.tan(double, double)", input, + Math.tan(input), expected, ulps); + return failures; + } + + static int testTan() { + int failures = 0; + + double [][] testCases = { + // 1.1 ulp case from Gonnet + {0x1.31b97c4000001p24, -0x1.d08538b656222p34, 1.9}, + // Remaining test cases adapted from work by Alex Liu + {0x1.be1b2d17ba207p6, -0x1.cf489c89f8066p49, 1.100000}, + {0x1.e0a9e6ab97de7p7, 0x1.d31ce95f57459p50, 1.100000}, + {0x1.23f8c5bcf003ep11, 0x1.f022585dbb50ap50, 1.100000}, + {0x1.44bdb557e1dc1p20, 0x1.b67eaf362701fp49, 1.100000}, + {0x1.604759040fb6fp68, 0x1.d574bc1f9e903p50, 1.100000}, + {0x1.3d33fa4e5ba47p70, 0x1.ce1dd6e33fef8p49, 1.100000}, + {0x1.f19e5d71b26bap85, 0x1.c2536a9119dd2p55, 1.100000}, + {0x1.43ed062d2d62cp88, -0x1.c94b0c5b7b05p49, 1.100000}, + {0x1.b7b895b030bep88, -0x1.cba9ebb0f20b9p51, 1.100000}, + {0x1.a86090fe7c144p95, 0x1.d5ad72ca48bbfp48, 1.100000}, + {0x1.d199df0700a61p95, -0x1.b8dd636f8dba7p49, 1.100000}, + {0x1.d713037d1d222p106, -0x1.d57f035fd0146p48, 1.100000}, + {0x1.ed1f6b066569bp115, 0x1.840af46cc9bep48, 1.100000}, + {0x1.16800a51eff75p118, 0x1.c9f91caf08a6ap49, 1.100000}, + {0x1.c1169c1040ecdp134, 0x1.e44a7eb56cb7p48, 1.100000}, + {0x1.19b0fb40dddd5p145, -0x1.f1b1c235774b2p48, 1.100000}, + {0x1.4d6b47f2480f8p162, 0x1.da1c2010795a5p51, 1.100000}, + {0x1.682ff8e5429ddp163, -0x1.95a7aee1e93bep55, 1.100000}, + {0x1.d0569fad9657dp204, -0x1.8f2ca17123aa5p49, 1.100000}, + {0x1.55505de5bbc14p206, -0x1.e8d28e39ddf9p50, 1.100000}, + {0x1.cf497083e6c77p206, -0x1.fd3fbaa40de18p49, 1.100000}, + {0x1.c5b30c8686203p214, 0x1.f4d14469638a9p48, 1.100000}, + {0x1.60d15b12ff0b7p217, 0x1.bc150932bd3d7p48, 1.100000}, + {0x1.07cc6858d980bp218, -0x1.f3f7355c983a5p51, 1.100000}, + {0x1.e06a67cd86969p218, 0x1.b0873124d98afp51, 1.100000}, + {0x1.49704174c38e3p229, 0x1.e0301142ccbc2p49, 1.100000}, + {0x1.ea19ceab3b06ap230, -0x1.fc22e687f0482p48, 1.100000}, + {0x1.0c905503fea72p236, -0x1.7d4e9a45014d5p49, 1.100000}, + {0x1.28eb1f8ddd7c3p257, -0x1.a951893680c71p49, 1.100000}, + {0x1.310b11af2bfbep260, 0x1.84d458039c2e6p48, 1.100000}, + {0x1.f3c172bb7afc2p265, -0x1.fb3139d3ba04fp49, 1.100000}, + {0x1.54a28326cfedep267, 0x1.f416de8fb60bap53, 1.100000}, + {0x1.5a5154d9d609dp269, -0x1.83d74cea8141p51, 1.100000}, + {0x1.3ee75fd803b21p275, 0x1.b9ab67b61bf65p50, 1.100000}, + {0x1.f4a4c781834d9p277, -0x1.d639ec63bf3b6p49, 1.100000}, + {0x1.2053d5c14cf78p279, 0x1.fc31413372cdcp50, 1.100000}, + {0x1.896d0a9acee4cp298, 0x1.f9136d6e27a5cp48, 1.100000}, + {0x1.f010da08a862p302, -0x1.fd812c5e13483p49, 1.100000}, + {0x1.65f2e272f729fp308, -0x1.f9f642ddaa32dp49, 1.100000}, + {0x1.a8afbc4edb07dp309, 0x1.fa0d458320902p52, 1.100000}, + {0x1.4d311a5447cdep329, -0x1.f7e98fe193e81p49, 1.100000}, + {0x1.808f66338b21bp345, -0x1.bceaf45f61155p49, 1.100000}, + {0x1.5a34aacf5ded1p350, 0x1.d41f0f13fadd4p49, 1.100000}, + {0x1.3e8b85532bad1p354, -0x1.f0b21179d663ep49, 1.100000}, + {0x1.1c2ecf01570acp394, -0x1.c215c9e2b7b24p49, 1.100000}, + {0x1.666eba99d2837p402, 0x1.fbd5c4b527506p48, 1.100000}, + {0x1.6cc39f07fafbbp460, -0x1.f087548a00e7cp49, 1.100000}, + {0x1.9481228fea3ffp463, -0x1.c585e64ff44c8p48, 1.100000}, + {0x1.79c3af0b4d0d4p466, 0x1.c9ed3716691f2p51, 1.100000}, + {0x1.993ea84c3e23bp468, 0x1.a6b3954fc37f3p49, 1.100000}, + {0x1.cfd6b13f64408p470, -0x1.f4db7cc2c09bp47, 1.100000}, + {0x1.b820ccdd52299p473, 0x1.77a1ff863b0f3p52, 1.100000}, + {0x1.157ef3a1528a5p475, -0x1.f4e14ddc45e49p51, 1.100000}, + {0x1.b492a8997bc36p478, -0x1.e0db26b7f03e8p48, 1.100000}, + {0x1.e0ea5674b831bp480, 0x1.e0ad6b3cdccdfp48, 1.100000}, + {0x1.c62ac8b32cb9ep497, 0x1.c95d00a36f677p48, 1.100000}, + {0x1.467f1daf12b43p498, 0x1.c6d3fdc096f0bp50, 1.100000}, + {0x1.336e5a83e390cp502, 0x1.fc873dae28572p48, 1.100000}, + {0x1.aaab1de0d6727p506, -0x1.e0482967d0354p49, 1.100000}, + {0x1.e5ce06a12139cp507, 0x1.cea42e29735bdp49, 1.100000}, + {0x1.87dad74d0dda8p516, -0x1.b2cde6c0a8b9fp48, 1.100000}, + {0x1.e4feb94ee0989p524, -0x1.b227d0d0ffaa8p49, 1.100000}, + {0x1.31c082b1361ebp525, 0x1.a7ed49158d736p49, 1.100000}, + {0x1.56913865b3e16p531, 0x1.eeb7a32591c3bp52, 1.100000}, + {0x1.36ade1fa883cap544, -0x1.fa087aadc0cbp48, 1.100000}, + {0x1.de57314df4af8p559, 0x1.c686aa5a41075p49, 1.100000}, + {0x1.0bb29bf7960ddp586, -0x1.d29ae1a3023cep50, 1.100000}, + {0x1.049a584685941p588, -0x1.eebfb159dba67p51, 1.100000}, + {0x1.33c1d4257b294p589, 0x1.ea1eedabea109p48, 1.100000}, + {0x1.3587e511bf47bp590, 0x1.c897858ce0ca9p48, 1.100000}, + {0x1.d12ee010c0facp590, 0x1.ab5b4b5065aa3p48, 1.100000}, + {0x1.87bbed5af48d9p605, 0x1.f512c3b2be7cap50, 1.100000}, + {0x1.a0b1131240cebp605, -0x1.fa373983fd571p48, 1.100000}, + {0x1.116fdda1a04c9p616, -0x1.d76fdbc8552f3p51, 1.100000}, + {0x1.67ebae833a034p620, 0x1.e1313af0a4075p50, 1.100000}, + {0x1.9a50fbc5b0fecp627, 0x1.d89150884fbf7p50, 1.100000}, + {0x1.6d625e0757e9cp631, -0x1.d0a5ecf002555p49, 1.100000}, + {0x1.e880344cc9913p636, -0x1.fafd04caaf58bp48, 1.100000}, + {0x1.e0a180b843cc5p650, 0x1.ea2aea3b8c953p49, 1.100000}, + {0x1.fa91ce15157b2p652, 0x1.e6f5f4d47d83fp48, 1.100000}, + {0x1.7696347caf8dfp654, 0x1.e0d36f2aef7dap51, 1.100000}, + {0x1.886484b536161p666, -0x1.e3c96481e335bp51, 1.100000}, + {0x1.0aa3ff2b41abdp675, -0x1.b3300ee04b4c8p50, 1.100000}, + {0x1.d695ac08fe897p675, -0x1.c27fd21ecb13p51, 1.100000}, + {0x1.4c1e532d7a99ap680, 0x1.e2ec695260c39p49, 1.100000}, + {0x1.44a9f3e395802p685, -0x1.e7273ab9ce8e2p52, 1.100000}, + {0x1.3a25ec2b43d45p697, -0x1.d23187ba6321ep49, 1.100000}, + {0x1.96f5c2420c3fdp716, -0x1.ea06ab71ad719p49, 1.100000}, + {0x1.926c063a9406bp741, 0x1.e3d3d9262fd66p48, 1.100000}, + {0x1.1a57713d6fd93p754, -0x1.c10074d49490dp48, 1.100000}, + {0x1.739387922e672p772, 0x1.bda527e215a3cp49, 1.100000}, + {0x1.d286eff17f4d4p793, 0x1.d01c678ebfa1p49, 1.100000}, + {0x1.f3d777206a062p794, -0x1.d8604b6d18385p49, 1.100000}, + {0x1.ae91e6574da91p826, -0x1.fd1b26ab656c2p49, 1.100000}, + {0x1.4422b3c871c9p836, 0x1.9d2cab1f3aebcp48, 1.100000}, + {0x1.7ff8537071e1p840, 0x1.badde451c6ed7p48, 1.100000}, + {0x1.c6fe9202e219dp845, -0x1.b2aa20745de3p51, 1.100000}, + {0x1.a95a0b4015d88p846, 0x1.cdf5dfd045657p50, 1.100000}, + {0x1.f823b9cff0daep867, 0x1.fd72fce3d5505p48, 1.100000}, + {0x1.a6bee2afcd2fp886, 0x1.fe06265cd3aebp49, 1.100000}, + {0x1.7b034b3412d17p892, 0x1.e48055812d391p50, 1.100000}, + {0x1.58588f8cda276p894, 0x1.f806fddf0dd05p53, 1.100000}, + {0x1.ce750a7963463p896, 0x1.e94f1f4018402p48, 1.100000}, + {0x1.3d50a91fe82cfp897, 0x1.cd518fda10e95p48, 1.100000}, + {0x1.f82dea1c0b809p897, -0x1.d6a0ef08179c5p48, 1.100000}, + {0x1.38673e8c6a4afp903, 0x1.f4113a036478p48, 1.100000}, + {0x1.dfb75e4a7432p911, 0x1.eb7bc6cb4d7f3p48, 1.100000}, + {0x1.1230b975a72b3p916, -0x1.e1042be0759f9p48, 1.100000}, + {0x1.302c2f5a4e6e5p916, 0x1.f66a9874cd60ap48, 1.100000}, + {0x1.04e07a1d67b93p921, 0x1.87735139f6a0bp53, 1.100000}, + {0x1.5a3eb79cd06fap931, -0x1.e00930c219ef3p51, 1.100000}, + {0x1.8fb45679936fp937, 0x1.9a427588645c4p50, 1.100000}, + {0x1.c4abb225260c6p964, -0x1.d1e64e91ac6ap50, 1.100000}, + {0x1.b43e449b25382p982, -0x1.f1848cc5ac4fep50, 1.100000}, + {0x1.504d9d7179b1ap983, 0x1.a4e51ea807786p48, 1.100000}, + {0x1.83a5af80fb39bp987, 0x1.a6dde6c2220ebp48, 1.100000}, + {0x1.5d978d9ad84c8p1011, 0x1.ec96900bfd1ddp51, 1.100000}, + }; + + for(double[] testCase: testCases) { + failures += testTanCase(testCase[0], testCase[1], testCase[2]); + } + + return failures; + } + + public static void main(String [] argv) { + int failures = 0; + + failures += testTan(); + + if (failures > 0) { + System.err.println("Testing tan incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:43 2009 +++ new/test/java/lang/Math/Tests.java Mon Jan 26 16:12:42 2009 @@ -0,0 +1,341 @@ +/* + * Copyright 2003 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. + */ + +/* + * Shared static test methods for numerical tests. Sharing these + * helper test methods avoids repeated functions in the various test + * programs. The test methods return 1 for a test failure and 0 for + * success. The order of arguments to the test methods is generally + * the test name, followed by the test arguments, the computed result, + * and finally the expected result. + */ + +import sun.misc.FpUtils; + +public class Tests { + private Tests(){}; // do not instantiate + + private static String toHexString(float f) { + if (!Float.isNaN(f)) + return Float.toHexString(f); + else + return "NaN(0x" + Integer.toHexString(Float.floatToRawIntBits(f)) + ")"; + } + + private static String toHexString(double d) { + if (!Double.isNaN(d)) + return Double.toHexString(d); + else + return "NaN(0x" + Long.toHexString(Double.doubleToRawLongBits(d)) + ")"; + } + + public static int test(String testName, float input, + boolean result, boolean expected) { + if (expected != result) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\n" + + "\tgot " + result + ")."); + return 1; + } + else + return 0; + } + + public static int test(String testName, double input, + boolean result, boolean expected) { + if (expected != result) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\n" + + "\tgot " + result + ")."); + return 1; + } + else + return 0; + } + + public static int test(String testName, float input1, float input2, + boolean result, boolean expected) { + if (expected != result) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and " + + input2 + "\t(" + toHexString(input2) + ")\n" + + "\texpected " + expected + "\n" + + "\tgot " + result + ")."); + return 1; + } + return 0; + } + + public static int test(String testName, double input1, double input2, + boolean result, boolean expected) { + if (expected != result) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and " + + input2 + "\t(" + toHexString(input2) + ")\n" + + "\texpected " + expected + "\n" + + "\tgot " + result + ")."); + return 1; + } + return 0; + } + + public static int test(String testName, float input, + int result, int expected) { + if (expected != result) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\n" + + "\tgot " + result + ")."); + return 1; + } + return 0; + } + + public static int test(String testName, double input, + int result, int expected) { + if (expected != result) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\n" + + "\tgot " + result + ")."); + return 1; + } + else + return 0; + } + + public static int test(String testName, float input, + float result, float expected) { + if (Float.compare(expected, result) != 0 ) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + + public static int test(String testName, double input, + double result, double expected) { + if (Double.compare(expected, result ) != 0) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + public static int test(String testName, + float input1, double input2, + float result, float expected) { + if (Float.compare(expected, result ) != 0) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and " + + input2 + "\t(" + toHexString(input2) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + public static int test(String testName, + double input1, double input2, + double result, double expected) { + if (Double.compare(expected, result ) != 0) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and " + + input2 + "\t(" + toHexString(input2) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + public static int test(String testName, + float input1, int input2, + float result, float expected) { + if (Float.compare(expected, result ) != 0) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and " + + input2 + "\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + public static int test(String testName, + double input1, int input2, + double result, double expected) { + if (Double.compare(expected, result ) != 0) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and " + + input2 + "\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + static int testUlpCore(double result, double expected, double ulps) { + // We assume we won't be unlucky and have an inexact expected + // be nextDown(2^i) when 2^i would be the correctly rounded + // answer. This would cause the ulp size to be half as large + // as it should be, doubling the measured error). + + if (Double.compare(expected, result) == 0) { + return 0; // result and expected are equivalent + } else { + if( ulps == 0.0) { + // Equivalent results required but not found + return 1; + } else { + double difference = expected - result; + if (FpUtils.isUnordered(expected, result) || + Double.isNaN(difference) || + // fail if greater than or unordered + !(Math.abs( difference/Math.ulp(expected) ) <= Math.abs(ulps)) ) { + return 1; + } + else + return 0; + } + } + } + + // One input argument. + public static int testUlpDiff(String testName, double input, + double result, double expected, double ulps) { + int code = testUlpCore(result, expected, ulps); + if (code == 1) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ");\n" + + "\tdifference greater than ulp tolerance " + ulps); + } + return code; + } + + // Two input arguments. + public static int testUlpDiff(String testName, double input1, double input2, + double result, double expected, double ulps) { + int code = testUlpCore(result, expected, ulps); + if (code == 1) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor inputs " + input1 + "\t(" + toHexString(input1) + ") and " + + input2 + "\t(" + toHexString(input2) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ");\n" + + "\tdifference greater than ulp tolerance " + ulps); + } + return code; + } + + // For a successful test, the result must be within the ulp bound of + // expected AND the result must have absolute value less than or + // equal to absBound. + public static int testUlpDiffWithAbsBound(String testName, double input, + double result, double expected, + double ulps, double absBound) { + int code = 0; // return code value + + if (!(StrictMath.abs(result) <= StrictMath.abs(absBound)) && + !Double.isNaN(expected)) { + code = 1; + } else + code = testUlpCore(result, expected, ulps); + + if (code == 1) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ");\n" + + "\tdifference greater than ulp tolerance " + ulps + + " or the result has larger magnitude than " + absBound); + } + return code; + } + + // For a successful test, the result must be within the ulp bound of + // expected AND the result must have absolute value greater than + // or equal to the lowerBound. + public static int testUlpDiffWithLowerBound(String testName, double input, + double result, double expected, + double ulps, double lowerBound) { + int code = 0; // return code value + + if (!(result >= lowerBound) && !Double.isNaN(expected)) { + code = 1; + } else + code = testUlpCore(result, expected, ulps); + + if (code == 1) { + System.err.println("Failure for " + testName + + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")" + + "\n\texpected " + expected + "\t(" + toHexString(expected) + ")" + + "\n\tgot " + result + "\t(" + toHexString(result) + ");" + + "\ndifference greater than ulp tolerance " + ulps + + " or result not greater than or equal to the bound " + lowerBound); + } + return code; + } + + public static int testTolerance(String testName, double input, + double result, double expected, double tolerance) { + if (Double.compare(expected, result ) != 0) { + double difference = expected - result; + if (FpUtils.isUnordered(expected, result) || + Double.isNaN(difference) || + // fail if greater than or unordered + !(Math.abs((difference)/expected) <= StrictMath.pow(10, -tolerance)) ) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + toHexString(input) + ")\n" + + "\texpected " + expected + "\t(" + toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + toHexString(result) + ");\n" + + "\tdifference greater than tolerance 10^-" + tolerance); + return 1; + } + return 0; + } + else + return 0; + } +} --- /dev/null Mon Jan 26 16:12:45 2009 +++ new/test/java/lang/Short/ByteSwap.java Mon Jan 26 16:12:44 2009 @@ -0,0 +1,39 @@ +/* + * Copyright 2003 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 4495754 + * @summary Basic test for int byte swap code on short and char + * @author Josh Bloch + */ + +public class ByteSwap { + public static void main(String args[]) { + if (Short.reverseBytes((short)0xaabb) != (short)0xbbaa) + throw new RuntimeException("short"); + + if (Character.reverseBytes((char)0xaabb) != (char)0xbbaa) + throw new RuntimeException("char"); + } +} --- /dev/null Mon Jan 26 16:12:47 2009 +++ new/test/java/lang/Short/Decode.java Mon Jan 26 16:12:46 2009 @@ -0,0 +1,98 @@ +/* + * Copyright 1998-2007 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 4136371 5017980 6576055 + * @summary Test Short.decode method + * @author madbot + * @author Joseph D. Darcy + */ + +/** + * There are six methods in java.lang.Short which transform strings + * into a short or Short value: + * + * public Short(String s) + * public static Short decode(String nm) + * public static short parseShort(String s, int radix) + * public static short parseShort(String s) + * public static Short valueOf(String s, int radix) + * public static Short valueOf(String s) + * + * However, of these only decode has a nontrivial implementation + * in that class. + */ +public class Decode { + + private static void check(String ashort, short expected) { + short sh = (Short.decode(ashort)).shortValue(); + if (sh != expected) + throw new RuntimeException("Short.decode failed. String:" + + ashort + " Result:" + sh); + } + + private static void checkFailure(String val, String message) { + try { + short n = (Short.decode(val)).shortValue(); + throw new RuntimeException(message); + } catch (NumberFormatException e) { /* Okay */} + } + + public static void main(String[] args) throws Exception { + check(new String(""+Short.MIN_VALUE), Short.MIN_VALUE); + check(new String(""+Short.MAX_VALUE), Short.MAX_VALUE); + + check("10", (short)10); + check("0x10", (short)16); + check("0X10", (short)16); + check("010", (short)8); + check("#10", (short)16); + + check("+10", (short)10); + check("+0x10", (short)16); + check("+0X10", (short)16); + check("+010", (short)8); + check("+#10", (short)16); + + check("-10", (short)-10); + check("-0x10", (short)-16); + check("-0X10", (short)-16); + check("-010", (short)-8); + check("-#10", (short)-16); + + check(Integer.toString((int)Short.MIN_VALUE), Short.MIN_VALUE); + check(Integer.toString((int)Short.MAX_VALUE), Short.MAX_VALUE); + + checkFailure("0x-10", "Short.decode allows negative sign in wrong position."); + checkFailure("0x+10", "Short.decode allows positive sign in wrong position."); + + checkFailure("+", "Raw plus sign allowed."); + checkFailure("-", "Raw minus sign allowed."); + + checkFailure(Integer.toString((int)Short.MIN_VALUE - 1), "Out of range"); + checkFailure(Integer.toString((int)Short.MAX_VALUE + 1), "Out of range"); + + checkFailure("", "Empty String"); + } +} --- /dev/null Mon Jan 26 16:12:50 2009 +++ new/test/java/lang/StrictMath/CubeRootTests.java Mon Jan 26 16:12:49 2009 @@ -0,0 +1,473 @@ +/* + * 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 4347132 + * @summary Tests specifically for StrictMath.cbrt + * @author Joseph D. Darcy + */ + +/** + * The tests in ../Math/CubeRootTests.java test properties that should + * hold for any cube root implementation, including the FDLIBM-based + * one required for StrictMath.cbrt. Therefore, the test cases in + * ../Math/CubeRootTests.java are run against both the Math and + * StrictMath versions of cube root. The role of this test is to + * verify that the FDLIBM cbrt algorithm is being used by running + * golden file tests on values that may vary from one conforming cube + * root implementation to another. + */ + +public class CubeRootTests { + private CubeRootTests(){} + + static int testCubeRootCase(double input, double expected) { + int failures=0; + + double minus_input = -input; + double minus_expected = -expected; + + failures+=Tests.test("StrictMath.cbrt(double)", input, + StrictMath.cbrt(input), expected); + failures+=Tests.test("StrictMath.cbrt(double)", minus_input, + StrictMath.cbrt(minus_input), minus_expected); + return failures; + } + + static int testCubeRoot() { + int failures = 0; + double [][] testCases = { + {0x1.ffffffffffffep-766, 0x1.fffffffffffffp-256}, + {0x1.ffffffffffffep-763, 0x1.fffffffffffffp-255}, + {0x1.ffffffffffffep-760, 0x1.fffffffffffffp-254}, + {0x1.ffffffffffffep-757, 0x1.fffffffffffffp-253}, + {0x1.ffffffffffffep-754, 0x1.fffffffffffffp-252}, + {0x1.ffffffffffffep-751, 0x1.fffffffffffffp-251}, + {0x1.ffffffffffffep-748, 0x1.fffffffffffffp-250}, + {0x1.ffffffffffffep-745, 0x1.fffffffffffffp-249}, + {0x1.ffffffffffffep-742, 0x1.fffffffffffffp-248}, + {0x1.ffffffffffffep-739, 0x1.fffffffffffffp-247}, + {0x1.ffffffffffffep-1006, 0x1.fffffffffffffp-336}, + {0x1.ffffffffffffep-736, 0x1.fffffffffffffp-246}, + {0x1.ffffffffffffep-733, 0x1.fffffffffffffp-245}, + {0x1.ffffffffffffep-730, 0x1.fffffffffffffp-244}, + {0x1.ffffffffffffep-727, 0x1.fffffffffffffp-243}, + {0x1.ffffffffffffep-724, 0x1.fffffffffffffp-242}, + {0x1.ffffffffffffep-721, 0x1.fffffffffffffp-241}, + {0x1.ffffffffffffep-718, 0x1.fffffffffffffp-240}, + {0x1.ffffffffffffep-715, 0x1.fffffffffffffp-239}, + {0x1.ffffffffffffep-712, 0x1.fffffffffffffp-238}, + {0x1.ffffffffffffep-709, 0x1.fffffffffffffp-237}, + {0x1.ffffffffffffep-706, 0x1.fffffffffffffp-236}, + {0x1.ffffffffffffep-703, 0x1.fffffffffffffp-235}, + {0x1.ffffffffffffep-700, 0x1.fffffffffffffp-234}, + {0x1.ffffffffffffep-697, 0x1.fffffffffffffp-233}, + {0x1.ffffffffffffep-694, 0x1.fffffffffffffp-232}, + {0x1.ffffffffffffep-691, 0x1.fffffffffffffp-231}, + {0x1.ffffffffffffep-1003, 0x1.fffffffffffffp-335}, + {0x1.ffffffffffffep-688, 0x1.fffffffffffffp-230}, + {0x1.ffffffffffffep-685, 0x1.fffffffffffffp-229}, + {0x1.ffffffffffffep-682, 0x1.fffffffffffffp-228}, + {0x1.ffffffffffffep-679, 0x1.fffffffffffffp-227}, + {0x1.ffffffffffffep-676, 0x1.fffffffffffffp-226}, + {0x1.ffffffffffffep-673, 0x1.fffffffffffffp-225}, + {0x1.ffffffffffffep-670, 0x1.fffffffffffffp-224}, + {0x1.ffffffffffffep-667, 0x1.fffffffffffffp-223}, + {0x1.ffffffffffffep-664, 0x1.fffffffffffffp-222}, + {0x1.ffffffffffffep-661, 0x1.fffffffffffffp-221}, + {0x1.ffffffffffffep-658, 0x1.fffffffffffffp-220}, + {0x1.ffffffffffffep-655, 0x1.fffffffffffffp-219}, + {0x1.ffffffffffffep-652, 0x1.fffffffffffffp-218}, + {0x1.ffffffffffffep-649, 0x1.fffffffffffffp-217}, + {0x1.ffffffffffffep-646, 0x1.fffffffffffffp-216}, + {0x1.ffffffffffffep-643, 0x1.fffffffffffffp-215}, + {0x1.ffffffffffffep-1000, 0x1.fffffffffffffp-334}, + {0x1.ffffffffffffep-640, 0x1.fffffffffffffp-214}, + {0x1.ffffffffffffep-637, 0x1.fffffffffffffp-213}, + {0x1.ffffffffffffep-634, 0x1.fffffffffffffp-212}, + {0x1.ffffffffffffep-631, 0x1.fffffffffffffp-211}, + {0x1.ffffffffffffep-628, 0x1.fffffffffffffp-210}, + {0x1.ffffffffffffep-625, 0x1.fffffffffffffp-209}, + {0x1.ffffffffffffep-622, 0x1.fffffffffffffp-208}, + {0x1.ffffffffffffep-619, 0x1.fffffffffffffp-207}, + {0x1.ffffffffffffep-616, 0x1.fffffffffffffp-206}, + {0x1.ffffffffffffep-613, 0x1.fffffffffffffp-205}, + {0x1.ffffffffffffep-610, 0x1.fffffffffffffp-204}, + {0x1.ffffffffffffep-607, 0x1.fffffffffffffp-203}, + {0x1.ffffffffffffep-604, 0x1.fffffffffffffp-202}, + {0x1.ffffffffffffep-601, 0x1.fffffffffffffp-201}, + {0x1.ffffffffffffep-598, 0x1.fffffffffffffp-200}, + {0x1.ffffffffffffep-595, 0x1.fffffffffffffp-199}, + {0x1.ffffffffffffep-997, 0x1.fffffffffffffp-333}, + {0x1.ffffffffffffep-592, 0x1.fffffffffffffp-198}, + {0x1.ffffffffffffep-589, 0x1.fffffffffffffp-197}, + {0x1.ffffffffffffep-586, 0x1.fffffffffffffp-196}, + {0x1.ffffffffffffep-583, 0x1.fffffffffffffp-195}, + {0x1.ffffffffffffep-580, 0x1.fffffffffffffp-194}, + {0x1.ffffffffffffep-577, 0x1.fffffffffffffp-193}, + {0x1.ffffffffffffep-574, 0x1.fffffffffffffp-192}, + {0x1.ffffffffffffep-571, 0x1.fffffffffffffp-191}, + {0x1.ffffffffffffep-568, 0x1.fffffffffffffp-190}, + {0x1.ffffffffffffep-565, 0x1.fffffffffffffp-189}, + {0x1.ffffffffffffep-562, 0x1.fffffffffffffp-188}, + {0x1.ffffffffffffep-559, 0x1.fffffffffffffp-187}, + {0x1.ffffffffffffep-556, 0x1.fffffffffffffp-186}, + {0x1.ffffffffffffep-553, 0x1.fffffffffffffp-185}, + {0x1.ffffffffffffep-550, 0x1.fffffffffffffp-184}, + {0x1.ffffffffffffep-547, 0x1.fffffffffffffp-183}, + {0x1.ffffffffffffep-994, 0x1.fffffffffffffp-332}, + {0x1.ffffffffffffep-544, 0x1.fffffffffffffp-182}, + {0x1.ffffffffffffep-541, 0x1.fffffffffffffp-181}, + {0x1.ffffffffffffep-538, 0x1.fffffffffffffp-180}, + {0x1.ffffffffffffep-535, 0x1.fffffffffffffp-179}, + {0x1.ffffffffffffep-532, 0x1.fffffffffffffp-178}, + {0x1.ffffffffffffep-529, 0x1.fffffffffffffp-177}, + {0x0.00000000001fp-1022, 0x1.fa9c313858568p-356}, + {0x1.ffffffffffffep-526, 0x1.fffffffffffffp-176}, + {0x1.ffffffffffffep-523, 0x1.fffffffffffffp-175}, + {0x1.ffffffffffffep-520, 0x1.fffffffffffffp-174}, + {0x1.ffffffffffffep-517, 0x1.fffffffffffffp-173}, + {0x0.00000000001fdp-1022, 0x1.feff7f94ea34dp-356}, + {0x1.ffffffffffffep-514, 0x1.fffffffffffffp-172}, + {0x0.00000001fffe7p-1022, 0x1.ffff7aaa87f1bp-352}, + {0x0.00000001fffffp-1022, 0x1.fffffaaaaa9c7p-352}, + {0x0.00001ffffff4p-1022, 0x1.ffffffcp-348}, + {0x0.00001ffffffffp-1022, 0x1.ffffffffaaaabp-348}, + {0x0.01ffffffffffcp-1022, 0x1.ffffffffffeabp-344}, + {0x1.ffffffffffffep-511, 0x1.fffffffffffffp-171}, + {0x1.ffffffffffffep-508, 0x1.fffffffffffffp-170}, + {0x1.ffffffffffffep-505, 0x1.fffffffffffffp-169}, + {0x1.ffffffffffffep-502, 0x1.fffffffffffffp-168}, + {0x1.ffffffffffffep-499, 0x1.fffffffffffffp-167}, + {0x1.ffffffffffffep-991, 0x1.fffffffffffffp-331}, + {0x1.ffffffffffffep-496, 0x1.fffffffffffffp-166}, + {0x1.ffffffffffffep-493, 0x1.fffffffffffffp-165}, + {0x1.ffffffffffffep-490, 0x1.fffffffffffffp-164}, + {0x1.ffffffffffffep-487, 0x1.fffffffffffffp-163}, + {0x1.ffffffffffffep-484, 0x1.fffffffffffffp-162}, + {0x1.ffffffffffffep-481, 0x1.fffffffffffffp-161}, + {0x1.ffffffffffffep-478, 0x1.fffffffffffffp-160}, + {0x1.ffffffffffffep-475, 0x1.fffffffffffffp-159}, + {0x1.ffffffffffffep-472, 0x1.fffffffffffffp-158}, + {0x1.ffffffffffffep-469, 0x1.fffffffffffffp-157}, + {0x1.ffffffffffffep-466, 0x1.fffffffffffffp-156}, + {0x1.ffffffffffffep-463, 0x1.fffffffffffffp-155}, + {0x1.ffffffffffffep-460, 0x1.fffffffffffffp-154}, + {0x1.ffffffffffffep-457, 0x1.fffffffffffffp-153}, + {0x1.ffffffffffffep-454, 0x1.fffffffffffffp-152}, + {0x1.ffffffffffffep-451, 0x1.fffffffffffffp-151}, + {0x1.ffffffffffffep-988, 0x1.fffffffffffffp-330}, + {0x1.ffffffffffffep-448, 0x1.fffffffffffffp-150}, + {0x1.ffffffffffffep-445, 0x1.fffffffffffffp-149}, + {0x1.ffffffffffffep-442, 0x1.fffffffffffffp-148}, + {0x1.ffffffffffffep-439, 0x1.fffffffffffffp-147}, + {0x1.ffffffffffffep-436, 0x1.fffffffffffffp-146}, + {0x1.ffffffffffffep-433, 0x1.fffffffffffffp-145}, + {0x1.ffffffffffffep-430, 0x1.fffffffffffffp-144}, + {0x1.ffffffffffffep-427, 0x1.fffffffffffffp-143}, + {0x1.ffffffffffffep-424, 0x1.fffffffffffffp-142}, + {0x1.ffffffffffffep-421, 0x1.fffffffffffffp-141}, + {0x1.ffffffffffffep-418, 0x1.fffffffffffffp-140}, + {0x1.ffffffffffffep-415, 0x1.fffffffffffffp-139}, + {0x1.ffffffffffffep-412, 0x1.fffffffffffffp-138}, + {0x1.ffffffffffffep-409, 0x1.fffffffffffffp-137}, + {0x1.ffffffffffffep-406, 0x1.fffffffffffffp-136}, + {0x1.ffffffffffffep-403, 0x1.fffffffffffffp-135}, + {0x1.ffffffffffffep-985, 0x1.fffffffffffffp-329}, + {0x1.ffffffffffffep-400, 0x1.fffffffffffffp-134}, + {0x1.ffffffffffffep-397, 0x1.fffffffffffffp-133}, + {0x1.ffffffffffffep-394, 0x1.fffffffffffffp-132}, + {0x1.ffffffffffffep-391, 0x1.fffffffffffffp-131}, + {0x1.ffffffffffffep-388, 0x1.fffffffffffffp-130}, + {0x1.ffffffffffffep-385, 0x1.fffffffffffffp-129}, + {0x1.ffffffffffffep-382, 0x1.fffffffffffffp-128}, + {0x1.ffffffffffffep-379, 0x1.fffffffffffffp-127}, + {0x1.ffffffffffffep-376, 0x1.fffffffffffffp-126}, + {0x1.ffffffffffffep-373, 0x1.fffffffffffffp-125}, + {0x1.ffffffffffffep-370, 0x1.fffffffffffffp-124}, + {0x1.ffffffffffffep-367, 0x1.fffffffffffffp-123}, + {0x1.ffffffffffffep-364, 0x1.fffffffffffffp-122}, + {0x1.ffffffffffffep-361, 0x1.fffffffffffffp-121}, + {0x1.ffffffffffffep-358, 0x1.fffffffffffffp-120}, + {0x1.ffffffffffffep-355, 0x1.fffffffffffffp-119}, + {0x1.ffffffffffffep-982, 0x1.fffffffffffffp-328}, + {0x1.ffffffffffffep-352, 0x1.fffffffffffffp-118}, + {0x1.ffffffffffffep-349, 0x1.fffffffffffffp-117}, + {0x1.ffffffffffffep-346, 0x1.fffffffffffffp-116}, + {0x1.ffffffffffffep-343, 0x1.fffffffffffffp-115}, + {0x1.ffffffffffffep-340, 0x1.fffffffffffffp-114}, + {0x1.ffffffffffffep-337, 0x1.fffffffffffffp-113}, + {0x1.ffffffffffffep-334, 0x1.fffffffffffffp-112}, + {0x1.ffffffffffffep-331, 0x1.fffffffffffffp-111}, + {0x1.ffffffffffffep-328, 0x1.fffffffffffffp-110}, + {0x1.ffffffffffffep-325, 0x1.fffffffffffffp-109}, + {0x1.ffffffffffffep-322, 0x1.fffffffffffffp-108}, + {0x1.ffffffffffffep-319, 0x1.fffffffffffffp-107}, + {0x1.ffffffffffffep-316, 0x1.fffffffffffffp-106}, + {0x1.ffffffffffffep-313, 0x1.fffffffffffffp-105}, + {0x1.ffffffffffffep-310, 0x1.fffffffffffffp-104}, + {0x1.ffffffffffffep-307, 0x1.fffffffffffffp-103}, + {0x1.ffffffffffffep-979, 0x1.fffffffffffffp-327}, + {0x1.ffffffffffffep-304, 0x1.fffffffffffffp-102}, + {0x1.ffffffffffffep-301, 0x1.fffffffffffffp-101}, + {0x1.ffffffffffffep-298, 0x1.fffffffffffffp-100}, + {0x1.ffffffffffffep-295, 0x1.fffffffffffffp-99}, + {0x1.ffffffffffffep-292, 0x1.fffffffffffffp-98}, + {0x1.ffffffffffffep-289, 0x1.fffffffffffffp-97}, + {0x1.ffffffffffffep-286, 0x1.fffffffffffffp-96}, + {0x1.ffffffffffffep-283, 0x1.fffffffffffffp-95}, + {0x1.ffffffffffffep-280, 0x1.fffffffffffffp-94}, + {0x1.ffffffffffffep-277, 0x1.fffffffffffffp-93}, + {0x1.ffffffffffffep-274, 0x1.fffffffffffffp-92}, + {0x1.ffffffffffffep-271, 0x1.fffffffffffffp-91}, + {0x1.ffffffffffffep-268, 0x1.fffffffffffffp-90}, + {0x1.ffffffffffffep-265, 0x1.fffffffffffffp-89}, + {0x1.ffffffffffffep-262, 0x1.fffffffffffffp-88}, + {0x1.ffffffffffffep-259, 0x1.fffffffffffffp-87}, + {0x1.ffffffffffffep-1021, 0x1.fffffffffffffp-341}, + {0x1.ffffffffffffep-976, 0x1.fffffffffffffp-326}, + {0x1.ffffffffffffep-256, 0x1.fffffffffffffp-86}, + {0x1.ffffffffffffep-253, 0x1.fffffffffffffp-85}, + {0x1.ffffffffffffep-250, 0x1.fffffffffffffp-84}, + {0x1.ffffffffffffep-247, 0x1.fffffffffffffp-83}, + {0x1.ffffffffffffep-244, 0x1.fffffffffffffp-82}, + {0x1.ffffffffffffep-241, 0x1.fffffffffffffp-81}, + {0x1.ffffffffffffep-238, 0x1.fffffffffffffp-80}, + {0x1.ffffffffffffep-235, 0x1.fffffffffffffp-79}, + {0x1.ffffffffffffep-232, 0x1.fffffffffffffp-78}, + {0x1.ffffffffffffep-229, 0x1.fffffffffffffp-77}, + {0x1.ffffffffffffep-226, 0x1.fffffffffffffp-76}, + {0x1.ffffffffffffep-223, 0x1.fffffffffffffp-75}, + {0x1.ffffffffffffep-220, 0x1.fffffffffffffp-74}, + {0x1.ffffffffffffep-217, 0x1.fffffffffffffp-73}, + {0x1.ffffffffffffep-214, 0x1.fffffffffffffp-72}, + {0x1.ffffffffffffep-211, 0x1.fffffffffffffp-71}, + {0x1.ffffffffffffep-973, 0x1.fffffffffffffp-325}, + {0x1.ffffffffffffep-208, 0x1.fffffffffffffp-70}, + {0x1.ffffffffffffep-205, 0x1.fffffffffffffp-69}, + {0x1.ffffffffffffep-202, 0x1.fffffffffffffp-68}, + {0x1.ffffffffffffep-199, 0x1.fffffffffffffp-67}, + {0x1.ffffffffffffep-196, 0x1.fffffffffffffp-66}, + {0x1.ffffffffffffep-193, 0x1.fffffffffffffp-65}, + {0x1.ffffffffffffep-190, 0x1.fffffffffffffp-64}, + {0x1.ffffffffffffep-187, 0x1.fffffffffffffp-63}, + {0x1.ffffffffffffep-184, 0x1.fffffffffffffp-62}, + {0x1.ffffffffffffep-181, 0x1.fffffffffffffp-61}, + {0x1.ffffffffffffep-178, 0x1.fffffffffffffp-60}, + {0x1.ffffffffffffep-175, 0x1.fffffffffffffp-59}, + {0x1.ffffffffffffep-172, 0x1.fffffffffffffp-58}, + {0x1.ffffffffffffep-169, 0x1.fffffffffffffp-57}, + {0x1.ffffffffffffep-166, 0x1.fffffffffffffp-56}, + {0x1.ffffffffffffep-163, 0x1.fffffffffffffp-55}, + {0x1.ffffffffffffep-970, 0x1.fffffffffffffp-324}, + {0x1.ffffffffffffep-160, 0x1.fffffffffffffp-54}, + {0x1.ffffffffffffep-157, 0x1.fffffffffffffp-53}, + {0x1.ffffffffffffep-154, 0x1.fffffffffffffp-52}, + {0x1.ffffffffffffep-151, 0x1.fffffffffffffp-51}, + {0x1.ffffffffffffep-148, 0x1.fffffffffffffp-50}, + {0x1.ffffffffffffep-145, 0x1.fffffffffffffp-49}, + {0x1.ffffffffffffep-142, 0x1.fffffffffffffp-48}, + {0x1.ffffffffffffep-139, 0x1.fffffffffffffp-47}, + {0x1.ffffffffffffep-136, 0x1.fffffffffffffp-46}, + {0x1.ffffffffffffep-133, 0x1.fffffffffffffp-45}, + {0x1.ffffffffffffep-130, 0x1.fffffffffffffp-44}, + {0x1.ffffffffffffep-127, 0x1.fffffffffffffp-43}, + {0x1.ffffffffffffep-124, 0x1.fffffffffffffp-42}, + {0x1.ffffffffffffep-121, 0x1.fffffffffffffp-41}, + {0x1.ffffffffffffep-118, 0x1.fffffffffffffp-40}, + {0x1.ffffffffffffep-115, 0x1.fffffffffffffp-39}, + {0x1.ffffffffffffep-967, 0x1.fffffffffffffp-323}, + {0x1.ffffffffffffep-112, 0x1.fffffffffffffp-38}, + {0x1.ffffffffffffep-109, 0x1.fffffffffffffp-37}, + {0x1.ffffffffffffep-106, 0x1.fffffffffffffp-36}, + {0x1.ffffffffffffep-103, 0x1.fffffffffffffp-35}, + {0x1.ffffffffffffep-100, 0x1.fffffffffffffp-34}, + {0x1.ffffffffffffep-97, 0x1.fffffffffffffp-33}, + {0x1.ffffffffffffep-94, 0x1.fffffffffffffp-32}, + {0x1.ffffffffffffep-91, 0x1.fffffffffffffp-31}, + {0x1.ffffffffffffep-88, 0x1.fffffffffffffp-30}, + {0x1.ffffffffffffep-85, 0x1.fffffffffffffp-29}, + {0x1.ffffffffffffep-82, 0x1.fffffffffffffp-28}, + {0x1.ffffffffffffep-79, 0x1.fffffffffffffp-27}, + {0x1.ffffffffffffep-76, 0x1.fffffffffffffp-26}, + {0x1.ffffffffffffep-73, 0x1.fffffffffffffp-25}, + {0x1.ffffffffffffep-70, 0x1.fffffffffffffp-24}, + {0x1.ffffffffffffep-67, 0x1.fffffffffffffp-23}, + {0x1.ffffffffffffep-964, 0x1.fffffffffffffp-322}, + {0x1.ffffffffffffep-64, 0x1.fffffffffffffp-22}, + {0x1.ffffffffffffep-61, 0x1.fffffffffffffp-21}, + {0x1.ffffffffffffep-58, 0x1.fffffffffffffp-20}, + {0x1.ffffffffffffep-55, 0x1.fffffffffffffp-19}, + {0x1.ffffffffffffep-52, 0x1.fffffffffffffp-18}, + {0x1.ffffffffffffep-49, 0x1.fffffffffffffp-17}, + {0x1.ffffffffffffep-46, 0x1.fffffffffffffp-16}, + {0x1.ffffffffffffep-43, 0x1.fffffffffffffp-15}, + {0x1.ffffffffffffep-40, 0x1.fffffffffffffp-14}, + {0x1.ffffffffffffep-37, 0x1.fffffffffffffp-13}, + {0x1.ffffffffffffep-34, 0x1.fffffffffffffp-12}, + {0x1.ffffffffffffep-31, 0x1.fffffffffffffp-11}, + {0x1.ffffffffffffep-28, 0x1.fffffffffffffp-10}, + {0x1.ffffffffffffep-25, 0x1.fffffffffffffp-9}, + {0x1.ffffffffffffep-22, 0x1.fffffffffffffp-8}, + {0x0.000000000003ep-1022, 0x1.fa9c313858568p-357}, + {0x1.ffffffffffffep-19, 0x1.fffffffffffffp-7}, + {0x1.ffffffffffffep-961, 0x1.fffffffffffffp-321}, + {0x1.ffffffffffffep-16, 0x1.fffffffffffffp-6}, + {0x1.ffffffffffffep-13, 0x1.fffffffffffffp-5}, + {0x1.ffffffffffffep-10, 0x1.fffffffffffffp-4}, + {0x1.ffffffffffffep-7, 0x1.fffffffffffffp-3}, + {0x0.000000000003fp-1022, 0x1.fd51bf2069fe6p-357}, + {0x1.ffffffffffffep-4, 0x1.fffffffffffffp-2}, + {0x1.ffffffffffffep-1, 0x1.fffffffffffffp-1}, + {0x0.000000003fffcp-1022, 0x1.ffff55551c71bp-353}, + {0x0.000003fffffe8p-1022, 0x1.ffffffcp-349}, + {0x0.000003ffffffcp-1022, 0x1.fffffff555555p-349}, + {0x0.003fffffffff9p-1022, 0x1.fffffffffed55p-345}, + {0x1.ffffffffffffep2, 0x1.fffffffffffffp0}, + {0x1.bp4, 0x1.8p1}, + {0x1.ffffffffffffep5, 0x1.fffffffffffffp1}, + {0x1.f3ffffffffff4p6, 0x1.3fffffffffffep2}, + {0x1.f3ffffffffffcp6, 0x1.3ffffffffffffp2}, + {0x1.bp7, 0x1.8p2}, + {0x1.56ffffffffffep8, 0x1.bffffffffffffp2}, + {0x1.ffffffffffffep8, 0x1.fffffffffffffp2}, + {0x1.6c8p9, 0x1.2p3}, + {0x1.f3ffffffffff4p9, 0x1.3fffffffffffep3}, + {0x1.f3ffffffffffcp9, 0x1.3ffffffffffffp3}, + {0x1.4cbfffffffffcp10, 0x1.5fffffffffffep3}, + {0x1.4cbfffffffffep10, 0x1.5ffffffffffffp3}, + {0x1.bp10, 0x1.8p3}, + {0x1.129ffffffffa4p11, 0x1.9ffffffffffd1p3}, + {0x1.129fffffffffep11, 0x1.9ffffffffffffp3}, + {0x1.56ffffffffffep11, 0x1.bffffffffffffp3}, + {0x1.a5ep11, 0x1.ep3}, + {0x1.ffffffffffffep11, 0x1.fffffffffffffp3}, + {0x1.330fffffffc1ep12, 0x1.0fffffffffedbp4}, + {0x1.331p12, 0x1.1p4}, + {0x1.6c8p12, 0x1.2p4}, + {0x1.acafffffffffap12, 0x1.2ffffffffffffp4}, + {0x1.acafffffffffep12, 0x1.2ffffffffffffp4}, + {0x1.ffffffffffffep-958, 0x1.fffffffffffffp-320}, + {0x1.ffffffffffffep-955, 0x1.fffffffffffffp-319}, + {0x1.ffffffffffffep-952, 0x1.fffffffffffffp-318}, + {0x1.ffffffffffffep-949, 0x1.fffffffffffffp-317}, + {0x1.ffffffffffffep-946, 0x1.fffffffffffffp-316}, + {0x1.ffffffffffffep-943, 0x1.fffffffffffffp-315}, + {0x1.ffffffffffffep-940, 0x1.fffffffffffffp-314}, + {0x1.ffffffffffffep-937, 0x1.fffffffffffffp-313}, + {0x1.ffffffffffffep-934, 0x1.fffffffffffffp-312}, + {0x1.ffffffffffffep-931, 0x1.fffffffffffffp-311}, + {0x1.ffffffffffffep-1018, 0x1.fffffffffffffp-340}, + {0x1.ffffffffffffep-928, 0x1.fffffffffffffp-310}, + {0x1.ffffffffffffep-925, 0x1.fffffffffffffp-309}, + {0x1.ffffffffffffep-922, 0x1.fffffffffffffp-308}, + {0x1.ffffffffffffep-919, 0x1.fffffffffffffp-307}, + {0x1.ffffffffffffep-916, 0x1.fffffffffffffp-306}, + {0x1.ffffffffffffep-913, 0x1.fffffffffffffp-305}, + {0x1.ffffffffffffep-910, 0x1.fffffffffffffp-304}, + {0x1.ffffffffffffep-907, 0x1.fffffffffffffp-303}, + {0x1.ffffffffffffep-904, 0x1.fffffffffffffp-302}, + {0x0.0000000000007p-1022, 0x1.e9b5dba58189ep-358}, + {0x1.ffffffffffffep-901, 0x1.fffffffffffffp-301}, + {0x1.ffffffffffffep-898, 0x1.fffffffffffffp-300}, + {0x0.0000000007ffp-1022, 0x1.ffeaa9c70ca31p-354}, + {0x0.0000000007ffep-1022, 0x1.fffd5551c7149p-354}, + {0x0.0000007fffffdp-1022, 0x1.ffffffcp-350}, + {0x0.0000007fffffep-1022, 0x1.ffffffd555555p-350}, + {0x0.0007ffffffffap-1022, 0x1.fffffffff8p-346}, + {0x0.7ffffffffffffp-1022, 0x1.fffffffffffffp-342}, + {0x1.ffffffffffffep-895, 0x1.fffffffffffffp-299}, + {0x1.ffffffffffffep-892, 0x1.fffffffffffffp-298}, + {0x1.ffffffffffffep-889, 0x1.fffffffffffffp-297}, + {0x1.ffffffffffffep-886, 0x1.fffffffffffffp-296}, + {0x1.ffffffffffffep-883, 0x1.fffffffffffffp-295}, + {0x1.ffffffffffffep-1015, 0x1.fffffffffffffp-339}, + {0x1.ffffffffffffep-880, 0x1.fffffffffffffp-294}, + {0x1.ffffffffffffep-877, 0x1.fffffffffffffp-293}, + {0x1.ffffffffffffep-874, 0x1.fffffffffffffp-292}, + {0x1.ffffffffffffep-871, 0x1.fffffffffffffp-291}, + {0x1.ffffffffffffep-868, 0x1.fffffffffffffp-290}, + {0x1.ffffffffffffep-865, 0x1.fffffffffffffp-289}, + {0x1.ffffffffffffep-862, 0x1.fffffffffffffp-288}, + {0x1.ffffffffffffep-859, 0x1.fffffffffffffp-287}, + {0x1.ffffffffffffep-856, 0x1.fffffffffffffp-286}, + {0x1.ffffffffffffep-853, 0x1.fffffffffffffp-285}, + {0x1.ffffffffffffep-850, 0x1.fffffffffffffp-284}, + {0x1.ffffffffffffep-847, 0x1.fffffffffffffp-283}, + {0x1.ffffffffffffep-844, 0x1.fffffffffffffp-282}, + {0x1.ffffffffffffep-841, 0x1.fffffffffffffp-281}, + {0x1.ffffffffffffep-838, 0x1.fffffffffffffp-280}, + {0x1.ffffffffffffep-835, 0x1.fffffffffffffp-279}, + {0x1.ffffffffffffep-1012, 0x1.fffffffffffffp-338}, + {0x1.ffffffffffffep-832, 0x1.fffffffffffffp-278}, + {0x1.ffffffffffffep-829, 0x1.fffffffffffffp-277}, + {0x1.ffffffffffffep-826, 0x1.fffffffffffffp-276}, + {0x1.ffffffffffffep-823, 0x1.fffffffffffffp-275}, + {0x1.ffffffffffffep-820, 0x1.fffffffffffffp-274}, + {0x1.ffffffffffffep-817, 0x1.fffffffffffffp-273}, + {0x1.ffffffffffffep-814, 0x1.fffffffffffffp-272}, + {0x1.ffffffffffffep-811, 0x1.fffffffffffffp-271}, + {0x1.ffffffffffffep-808, 0x1.fffffffffffffp-270}, + {0x1.ffffffffffffep-805, 0x1.fffffffffffffp-269}, + {0x1.ffffffffffffep-802, 0x1.fffffffffffffp-268}, + {0x1.ffffffffffffep-799, 0x1.fffffffffffffp-267}, + {0x1.ffffffffffffep-796, 0x1.fffffffffffffp-266}, + {0x1.ffffffffffffep-793, 0x1.fffffffffffffp-265}, + {0x1.ffffffffffffep-790, 0x1.fffffffffffffp-264}, + {0x1.ffffffffffffep-787, 0x1.fffffffffffffp-263}, + {0x1.ffffffffffffep-1009, 0x1.fffffffffffffp-337}, + {0x1.ffffffffffffep-784, 0x1.fffffffffffffp-262}, + {0x1.ffffffffffffep-781, 0x1.fffffffffffffp-261}, + {0x1.ffffffffffffep-778, 0x1.fffffffffffffp-260}, + {0x1.ffffffffffffep-775, 0x1.fffffffffffffp-259}, + {0x1.ffffffffffffep-772, 0x1.fffffffffffffp-258}, + {0x1.ffffffffffffep-769, 0x1.fffffffffffffp-257}, + {0x0.0000000000ffep-1022, 0x1.ffeaa9c70ca31p-355}, + {0x0.0000000000fffp-1022, 0x1.fff5551c6fcd6p-355}, + {0x0.0000000ffff86p-1022, 0x1.ffffaeaa9dbf1p-351}, + {0x0.0000000ffffffp-1022, 0x1.ffffff5555552p-351}, + {0x0.0000ffffffap-1022, 0x1.ffffffcp-347}, + {0x0.0000ffffffff8p-1022, 0x1.ffffffffaaaabp-347}, + {0x0.0fffffffffffbp-1022, 0x1.fffffffffffcbp-343} + }; + + for(double[] testCase: testCases) + failures+=testCubeRootCase(testCase[0], testCase[1]); + + return failures; + } + + + public static void main(String [] argv) { + int failures = 0; + + failures += testCubeRoot(); + + if (failures > 0) { + System.err.println("Testing the cube root incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:52 2009 +++ new/test/java/lang/StrictMath/Expm1Tests.java Mon Jan 26 16:12:51 2009 @@ -0,0 +1,795 @@ +/* + * 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 4851638 + * @summary Tests for StrictMath.expm1 + * @author Joseph D. Darcy + */ + +/** + * The tests in ../Math/Expm1Tests.java test properties that should + * hold for any expm1 implementation, including the FDLIBM-based one + * required for StrictMath.expm1. Therefore, the test cases in + * ../Math/Expm1Tests.java are run against both the Math and + * StrictMath versions of expm1. The role of this test is to verify + * that the FDLIBM expm1 algorithm is being used by running golden + * file tests on values that may vary from one conforming expm1 + * implementation to another. + */ + +public class Expm1Tests { + private Expm1Tests(){} + + static int testExpm1Case(double input, double expected) { + return Tests.test("StrictMath.expm1(double)", input, + StrictMath.expm1(input), expected); + } + + static int testExpm1() { + int failures = 0; + + // Test cases in the range [-36.75, 710] + double [][] testCases = { + {-0x1.580000008c619p3, -0x1.fffd3069586f6p-1}, + {-0x1.380000008c721p3, -0x1.fff85bf4a6e98p-1}, + {-0x1.180000008c9fap3, -0x1.ffeb3aeb95524p-1}, + {-0x1.f0000001197ccp2, -0x1.ffc78aadc116ap-1}, + {-0x1.b0000001197e7p2, -0x1.ff6687cca710bp-1}, + {-0x1.70000001197f6p2, -0x1.fe5ed3992a519p-1}, + {-0x1.30000001198p2, -0x1.fb9201482bdfap-1}, + {-0x1.e000000233006p1, -0x1.f3f57b658d6fbp-1}, + {-0x1.6000000233012p1, -0x1.df44d8ee30b76p-1}, + {-0x1.c000000466028p0, -0x1.a7071a097ed5ep-1}, + {-0x1.80000008cc052p-1, -0x1.0e25f8a4a95b7p-1}, + {0x1.ffffffdccfeb7p-3, 0x1.22d78ef909144p-2}, + {0x1.3ffffffb99fd7p0, 0x1.3ec38ed3629a6p1}, + {0x1.1ffffffdccfebp1, 0x1.0f9b882a107edp3}, + {0x1.9ffffffdccfebp1, 0x1.8ca53b70fa11bp4}, + {0x1.0ffffffee67f6p2, 0x1.146bf132050c5p6}, + {0x1.4ffffffee67f5p2, 0x1.7b21ede9f0bdap7}, + {0x1.8ffffffee67f5p2, 0x1.0281a438aa523p9}, + {0x1.cffffffee67f5p2, 0x1.5fc6b5cf322c4p10}, + {0x1.07ffffff733fap3, 0x1.de5406b276b92p11}, + {0x1.27ffffff733fap3, 0x1.451c8690d1567p13}, + {0x1.47ffffff733fap3, 0x1.b9e62ae5924dfp14}, + {0x1.67ffffff733fap3, 0x1.2c4eeb7089cp16}, + {0x1.87ffffff733fap3, 0x1.982a24f2ab78ap17}, + {0x1.a7ffffff733fap3, 0x1.1560a14319349p19}, + {0x1.c7ffffff733fap3, 0x1.78fed772b40f2p20}, + {0x1.e7ffffff733fap3, 0x1.0031f18ee602fp22}, + {0x1.03ffffffb99fdp4, 0x1.5c348d8118f26p23}, + {0x1.13ffffffb99fdp4, 0x1.d942943e22d74p24}, + {0x1.23ffffffb99fcp4, 0x1.419d1309466ep26}, + {0x1.33ffffffb99fcp4, 0x1.b51e403430afep27}, + {0x1.43ffffffb99fcp4, 0x1.290d76c47bd4cp29}, + {0x1.53ffffffb99fcp4, 0x1.93bc8061146dp30}, + {0x1.63ffffffb99fbp4, 0x1.125e0665544a5p32}, + {0x1.73ffffffb99fbp4, 0x1.74e75f9de5d7cp33}, + {0x1.83ffffffb99fbp4, 0x1.fad42d3f28732p34}, + {0x1.93ffffffb99fbp4, 0x1.586d071cb8f87p36}, + {0x1.a3ffffffb99fbp4, 0x1.d41f91d0b4e6ep37}, + {0x1.b3ffffffb99fbp4, 0x1.3e1f6e5bc0242p39}, + {0x1.c3ffffffb99fbp4, 0x1.b05fa9aebfa64p40}, + {0x1.d3ffffffb99fbp4, 0x1.25d410cc90a38p42}, + {0x1.e3ffffffb99fbp4, 0x1.8f5aab33aa6c6p43}, + {0x1.f3ffffffb99fbp4, 0x1.0f63a91bc9797p45}, + {0x1.01ffffffdccfep5, 0x1.70db367c88b28p46}, + {0x1.09ffffffdccfep5, 0x1.f553e36d2975fp47}, + {0x1.11ffffffdccfep5, 0x1.54afff2230e99p49}, + {0x1.19ffffffdccfep5, 0x1.cf0ad451f1e9fp50}, + {0x1.21ffffffdccfep5, 0x1.3aab7c88ef991p52}, + {0x1.29ffffffdccfep5, 0x1.abae41ecccd22p53}, + {0x1.31ffffffdccfep5, 0x1.22a3a0462535fp55}, + {0x1.39ffffffdccfdp5, 0x1.8b050329f95c8p56}, + {0x1.41ffffffdccfdp5, 0x1.0c719224d80a2p58}, + {0x1.49ffffffdccfdp5, 0x1.6cda4c755ea56p59}, + {0x1.51ffffffdccfdp5, 0x1.efe2e2b6ad6ebp60}, + {0x1.59ffffffdccfdp5, 0x1.50fd5a6337c61p62}, + {0x1.61ffffffdccfdp5, 0x1.ca043518d78acp63}, + {0x1.69ffffffdccfdp5, 0x1.374122dd2fbdbp65}, + {0x1.71ffffffdccfdp5, 0x1.a709e46cc671ep66}, + {0x1.79ffffffdccfdp5, 0x1.1f7c0c5482bf3p68}, + {0x1.81ffffffdccfdp5, 0x1.86bb667297515p69}, + {0x1.89ffffffdccfcp5, 0x1.0987aa8375abcp71}, + {0x1.91ffffffdccfcp5, 0x1.68e48248f27ddp72}, + {0x1.99ffffffdccfcp5, 0x1.ea8100a2e27e9p73}, + {0x1.a1ffffffdccfcp5, 0x1.4d54fc02d9352p75}, + {0x1.a9ffffffdccfcp5, 0x1.c50b8ceab6ad1p76}, + {0x1.b1ffffffdccfcp5, 0x1.33e046afc7062p78}, + {0x1.b9ffffffdccfcp5, 0x1.a2726cf2e78e3p79}, + {0x1.c1ffffffdccfcp5, 0x1.1c5d3c581edf2p81}, + {0x1.c9ffffffdccfcp5, 0x1.827db3961daecp82}, + {0x1.d1ffffffdccfbp5, 0x1.06a5db797b4b2p84}, + {0x1.d9ffffffdccfbp5, 0x1.64f9b90e23fb4p85}, + {0x1.e1ffffffdccfbp5, 0x1.e52e132ebafe2p86}, + {0x1.e9ffffffdccfbp5, 0x1.49b6c774442efp88}, + {0x1.f1ffffffdccfbp5, 0x1.c020b4f9d926cp89}, + {0x1.f9ffffffdccfbp5, 0x1.3088cda20d465p91}, + {0x1.00ffffffee67ep6, 0x1.9de7b7a818186p92}, + {0x1.04ffffffee67ep6, 0x1.194717f5da259p94}, + {0x1.08ffffffee67ep6, 0x1.7e4bc97a2360dp95}, + {0x1.0cffffffee67ep6, 0x1.03cc0e87f367bp97}, + {0x1.10ffffffee67ep6, 0x1.6119d231b67f5p98}, + {0x1.14ffffffee67ep6, 0x1.dfe9f0cbe5942p99}, + {0x1.18ffffffee67ep6, 0x1.4622a079fc2a6p101}, + {0x1.1cffffffee67ep6, 0x1.bb4386e45ae94p102}, + {0x1.20ffffffee67ep6, 0x1.2d3a9d9e9fe6p104}, + {0x1.24ffffffee67ep6, 0x1.9969a118d6261p105}, + {0x1.28ffffffee67ep6, 0x1.1639871642331p107}, + {0x1.2cffffffee67ep6, 0x1.7a2587603a84bp108}, + {0x1.30ffffffee67ep6, 0x1.00fa2d6e6a76ep110}, + {0x1.34ffffffee67ep6, 0x1.5d44af7562574p111}, + {0x1.38ffffffee67ep6, 0x1.dab4705f88c02p112}, + {0x1.3cffffffee67ep6, 0x1.42986b24fc9dcp114}, + {0x1.40ffffffee67ep6, 0x1.b673dcb2fe519p115}, + {0x1.44ffffffee67ep6, 0x1.29f59cd896383p117}, + {0x1.48ffffffee67ep6, 0x1.94f806342143cp118}, + {0x1.4cffffffee67ep6, 0x1.133471e4d5b38p120}, + {0x1.50ffffffee67ep6, 0x1.760acce4f0e03p121}, + {0x1.54ffffffee67ep6, 0x1.fc604454828ddp122}, + {0x1.58ffffffee67ep6, 0x1.597a32eee8c46p124}, + {0x1.5cffffffee67ep6, 0x1.d58d694102246p125}, + {0x1.60ffffffee67ep6, 0x1.3f180bd3df0d2p127}, + {0x1.64ffffffee67ep6, 0x1.b1b190d803f07p128}, + {0x1.68ffffffee67ep6, 0x1.26b9b1cab82dap130}, + {0x1.6cffffffee67ep6, 0x1.9092c44a68bc1p131}, + {0x1.70ffffffee67ep6, 0x1.1037c0cf4a5a6p133}, + {0x1.74ffffffee67ep6, 0x1.71fb79fed30fbp134}, + {0x1.78ffffffee67ep6, 0x1.f6dbadec024eep135}, + {0x1.7cffffffee67ep6, 0x1.55ba3f072a6dbp137}, + {0x1.80ffffffee67ep6, 0x1.d074b338a9163p138}, + {0x1.84ffffffee67ep6, 0x1.3ba167320351ap140}, + {0x1.88ffffffee67ep6, 0x1.acfc7e2e0558bp141}, + {0x1.8cffffffee67ep6, 0x1.2386c336b7163p143}, + {0x1.90ffffffee67ep6, 0x1.8c39b90c7cdap144}, + {0x1.94ffffffee67ep6, 0x1.0d435c84d4e66p146}, + {0x1.98ffffffee67ep6, 0x1.6df76efd7275ep147}, + {0x1.9cffffffee67ep6, 0x1.f1666c9163f86p148}, + {0x1.a0ffffffee67ep6, 0x1.5204b679406b7p150}, + {0x1.a4ffffffee67ep6, 0x1.cb6a267e94b7ap151}, + {0x1.a8ffffffee67ep6, 0x1.38346236ba483p153}, + {0x1.acffffffee67ep6, 0x1.a8547ff6d3311p154}, + {0x1.b0ffffffee67ep6, 0x1.205cb8246899ap156}, + {0x1.b4ffffffee67ep6, 0x1.87ecc28a831c1p157}, + {0x1.b8ffffffee67ep6, 0x1.0a572df57323ep159}, + {0x1.bcffffffee67ep6, 0x1.69fe8c886de24p160}, + {0x1.c0ffffffee67ep6, 0x1.ec0055aa644acp161}, + {0x1.c4ffffffee67ep6, 0x1.4e597c5197d13p163}, + {0x1.c8ffffffee67ep6, 0x1.c66d9bb965746p164}, + {0x1.ccffffffee67ep6, 0x1.34d0e22472ce2p166}, + {0x1.d0ffffffee67ep6, 0x1.a3b971da5668ap167}, + {0x1.d4ffffffee67ep6, 0x1.1d3b77e103d1ap169}, + {0x1.d8ffffffee67ep6, 0x1.83abbf32ed4f6p170}, + {0x1.dcffffffee67ep6, 0x1.07731e5137e95p172}, + {0x1.e0ffffffee67ep6, 0x1.6610b39e7ce7p173}, + {0x1.e4ffffffee67ep6, 0x1.e6a93f132076cp174}, + {0x1.e8ffffffee67ep6, 0x1.4ab873ed0fb2cp176}, + {0x1.ecffffffee67ep6, 0x1.c17eebfd11debp177}, + {0x1.f0ffffffee67ep6, 0x1.3176cc87e9082p179}, + {0x1.f4ffffffee67ep6, 0x1.9f2b2fe57487ap180}, + {0x1.f8ffffffee67ep6, 0x1.1a22e9fe60816p182}, + {0x1.fcffffffee67ep6, 0x1.7f768dd1738aap183}, + {0x1.007ffffff733fp7, 0x1.049717079907bp185}, + {0x1.027ffffff733fp7, 0x1.622dc5947dd63p186}, + {0x1.047ffffff733fp7, 0x1.e160ff1ccd30cp187}, + {0x1.067ffffff733fp7, 0x1.472180f8199d7p189}, + {0x1.087ffffff733fp7, 0x1.bc9df0c9b6e0fp190}, + {0x1.0a7ffffff733fp7, 0x1.2e26073757ed6p192}, + {0x1.0c7ffffff733fp7, 0x1.9aa99688f714bp193}, + {0x1.0e7ffffff733fp7, 0x1.1712f6523864dp195}, + {0x1.107ffffff733fp7, 0x1.7b4d0d8e11012p196}, + {0x1.127ffffff733fp7, 0x1.01c301c6bf29cp198}, + {0x1.147ffffff733fp7, 0x1.5e55a41486608p199}, + {0x1.167ffffff733fp7, 0x1.dc276c8c7156p200}, + {0x1.187ffffff733fp7, 0x1.4394876ddc7dap202}, + {0x1.1a7ffffff733fp7, 0x1.b7ca840a6b3bap203}, + {0x1.1c7ffffff733fp7, 0x1.2ade7851ad0fep205}, + {0x1.1e7ffffff733fp7, 0x1.963482987606p206}, + {0x1.207ffffff733fp7, 0x1.140b84f56a91bp208}, + {0x1.227ffffff733fp7, 0x1.772f1dec03a66p209}, + {0x1.247ffffff733fp7, 0x1.fded90f5af3ap210}, + {0x1.267ffffff733fp7, 0x1.5a88311cf6cbdp212}, + {0x1.287ffffff733fp7, 0x1.d6fc5e99a419dp213}, + {0x1.2a7ffffff733fp7, 0x1.40116b9759ebap215}, + {0x1.2c7ffffff733fp7, 0x1.b304801416466p216}, + {0x1.2e7ffffff733fp7, 0x1.27a0063dbe9cep218}, + {0x1.307ffffff733fp7, 0x1.91cbd14945353p219}, + {0x1.327ffffff733fp7, 0x1.110c7e4340e4fp221}, + {0x1.347ffffff733fp7, 0x1.731c9ec8ce996p222}, + {0x1.367ffffff733fp7, 0x1.f864aa9acffbdp223}, + {0x1.387ffffff733fp7, 0x1.56c54eff8fbcdp225}, + {0x1.3a7ffffff733fp7, 0x1.d1dfaced4eb1p226}, + {0x1.3c7ffffff733fp7, 0x1.3c98120a95d78p228}, + {0x1.3e7ffffff733fp7, 0x1.ae4bbfa449eaap229}, + {0x1.407ffffff733fp7, 0x1.246a97a9838dcp231}, + {0x1.427ffffff733fp7, 0x1.8d6f603164cebp232}, + {0x1.447ffffff733fp7, 0x1.0e15cad8b775ep234}, + {0x1.467ffffff733fp7, 0x1.6f15705b3f514p235}, + {0x1.487ffffff733fp7, 0x1.f2eb25494787dp236}, + {0x1.4a7ffffff733fp7, 0x1.530ce0608a8acp238}, + {0x1.4c7ffffff733fp7, 0x1.ccd12fa07172p239}, + {0x1.4e7ffffff733fp7, 0x1.39285fa9c08e7p241}, + {0x1.507ffffff733fp7, 0x1.a9a01de01fd02p242}, + {0x1.527ffffff733fp7, 0x1.213e13894e05p244}, + {0x1.547ffffff733fp7, 0x1.891f0d4674b33p245}, + {0x1.567ffffff733fp7, 0x1.0b275393c60b2p247}, + {0x1.587ffffff733fp7, 0x1.6b1973327581dp248}, + {0x1.5a7ffffff733fp7, 0x1.ed80d645874cfp249}, + {0x1.5c7ffffff733fp7, 0x1.4f5ec835b4172p251}, + {0x1.5e7ffffff733fp7, 0x1.c7d0bf3aec5fcp252}, + {0x1.607ffffff733fp7, 0x1.35c239a263125p254}, + {0x1.627ffffff733fp7, 0x1.a501765319bp255}, + {0x1.647ffffff733fp7, 0x1.1e1a611707cfbp257}, + {0x1.667ffffff733fp7, 0x1.84dab6dcaac3cp258}, + {0x1.687ffffff733fp7, 0x1.08410192ab89ep260}, + {0x1.6a7ffffff733fp7, 0x1.67288834edb2fp261}, + {0x1.6c7ffffff733fp7, 0x1.e825934abdad9p262}, + {0x1.6e7ffffff733fp7, 0x1.4bbae9c58a222p264}, + {0x1.707ffffff733fp7, 0x1.c2de34b24b161p265}, + {0x1.727ffffff733fp7, 0x1.3265856c8dbdcp267}, + {0x1.747ffffff733fp7, 0x1.a06fa4ee04c8ep268}, + {0x1.767ffffff733fp7, 0x1.1aff67d171068p270}, + {0x1.787ffffff733fp7, 0x1.80a23ba5cc0fep271}, + {0x1.7a7ffffff733fp7, 0x1.0562be333b5b6p273}, + {0x1.7c7ffffff733fp7, 0x1.6342909f8e806p274}, + {0x1.7e7ffffff733fp7, 0x1.e2d932898c11cp275}, + {0x1.807ffffff733ep7, 0x1.482128a65b0aap277}, + {0x1.827ffffff733ep7, 0x1.bdf9696894p278}, + {0x1.847ffffff733ep7, 0x1.2f1228ca0924p280}, + {0x1.867ffffff733ep7, 0x1.9bea8605e05b8p281}, + {0x1.887ffffff733ep7, 0x1.17ed0f7b60befp283}, + {0x1.8a7ffffff733ep7, 0x1.7c757ab028d2cp284}, + {0x1.8c7ffffff733ep7, 0x1.028c73122cbaap286}, + {0x1.8e7ffffff733ep7, 0x1.5f676e04b872p287}, + {0x1.907ffffff733ep7, 0x1.dd9b8aa6c07f4p288}, + {0x1.927ffffff733ep7, 0x1.449168bd6830bp290}, + {0x1.947ffffff733ep7, 0x1.b922372b1b22fp291}, + {0x1.967ffffff733ep7, 0x1.2bc809c589606p293}, + {0x1.987ffffff733ep7, 0x1.9771f652c776ap294}, + {0x1.9a7ffffff733ep7, 0x1.14e3401b07fc7p296}, + {0x1.9c7ffffff733ep7, 0x1.785453659b7d4p297}, + {0x1.9e7ffffff733ep7, 0x1.ff7c1414d829fp298}, + {0x1.a07ffffff733ep7, 0x1.5b97024b58a63p300}, + {0x1.a27ffffff733ep7, 0x1.d86c72ba13072p301}, + {0x1.a47ffffff733ep7, 0x1.410b8e3e0a59p303}, + {0x1.a67ffffff733ep7, 0x1.b458783157a34p304}, + {0x1.a87ffffff733ep7, 0x1.28870eb1e33efp306}, + {0x1.aa7ffffff733ep7, 0x1.9305d2eedd47p307}, + {0x1.ac7ffffff733ep7, 0x1.11e1e1f93656cp309}, + {0x1.ae7ffffff733ep7, 0x1.743ea58a8a142p310}, + {0x1.b07ffffff733ep7, 0x1.f9eeda68dbff6p311}, + {0x1.b27ffffff733ep7, 0x1.57d12fadfda18p313}, + {0x1.b47ffffff733ep7, 0x1.d34bc24ce61e7p314}, + {0x1.b67ffffff733ep7, 0x1.3d8f7da8d8d95p316}, + {0x1.b87ffffff733ep7, 0x1.af9c071bbd116p317}, + {0x1.ba7ffffff733ep7, 0x1.254f1e2943f7fp319}, + {0x1.bc7ffffff733ep7, 0x1.8ea5f9553ce5ep320}, + {0x1.be7ffffff733ep7, 0x1.0ee8dda0a100cp322}, + {0x1.c07ffffff733ep7, 0x1.7034513ceac7dp323}, + {0x1.c27ffffff733ep7, 0x1.f4710dcb08bdcp324}, + {0x1.c47ffffff733ep7, 0x1.5415d8b9ef19cp326}, + {0x1.c67ffffff733ep7, 0x1.ce3951590b045p327}, + {0x1.c87ffffff733ep7, 0x1.3a1d1bcad2ec4p329}, + {0x1.ca7ffffff733ep7, 0x1.aaecbef297a4ap330}, + {0x1.cc7ffffff733ep7, 0x1.22201f0c6ae88p332}, + {0x1.ce7ffffff733ep7, 0x1.8a524760ebdc1p333}, + {0x1.d07ffffff733ep7, 0x1.0bf81bdd2ba52p335}, + {0x1.d27ffffff733ep7, 0x1.6c3536f34b0c2p336}, + {0x1.d47ffffff733ep7, 0x1.ef02835e6a7d8p337}, + {0x1.d67ffffff733ep7, 0x1.5064e04e480fep339}, + {0x1.d87ffffff733ep7, 0x1.c934f847894a8p340}, + {0x1.da7ffffff733ep7, 0x1.36b44dbc8b633p342}, + {0x1.dc7ffffff733ep7, 0x1.a64a7b24ebae2p343}, + {0x1.de7ffffff733ep7, 0x1.1ef9f881e57b8p345}, + {0x1.e07ffffff733ep7, 0x1.860a9b4bcf9dfp346}, + {0x1.e27ffffff733ep7, 0x1.090f85bb33493p348}, + {0x1.e47ffffff733ep7, 0x1.6841377bd96e9p349}, + {0x1.e67ffffff733ep7, 0x1.e9a310bd2715dp350}, + {0x1.e87ffffff733ep7, 0x1.4cbe299b1372dp352}, + {0x1.ea7ffffff733ep7, 0x1.c43e8fef69d0dp353}, + {0x1.ec7ffffff733ep7, 0x1.3354f8e156a72p355}, + {0x1.ee7ffffff733ep7, 0x1.a1b51787582dfp356}, + {0x1.f07ffffff733ep7, 0x1.1bdc91f54d333p358}, + {0x1.f27ffffff733ep7, 0x1.81ced3ada5ec9p359}, + {0x1.f47ffffff733ep7, 0x1.062f0486db268p361}, + {0x1.f67ffffff733ep7, 0x1.645833fb72196p362}, + {0x1.f87ffffff733ep7, 0x1.e4528bf7332d2p363}, + {0x1.fa7ffffff733ep7, 0x1.492198206b3aep365}, + {0x1.fc7ffffff733ep7, 0x1.bf55f194851b5p366}, + {0x1.fe7ffffff733ep7, 0x1.2fff02e67affep368}, + {0x1.003ffffffb99fp8, 0x1.9d2c7052fc80ep369}, + {0x1.013ffffffb99fp8, 0x1.18c7d31687cep371}, + {0x1.023ffffffb99fp8, 0x1.7d9ecf7b00132p372}, + {0x1.033ffffffb99fp8, 0x1.035681cb5b766p374}, + {0x1.043ffffffb99fp8, 0x1.607a0decadfaep375}, + {0x1.053ffffffb99fp8, 0x1.df10cb910ae14p376}, + {0x1.063ffffffb99fp8, 0x1.458f0fad99f57p378}, + {0x1.073ffffffb99fp8, 0x1.ba7af6e654fa2p379}, + {0x1.083ffffffb99fp8, 0x1.2cb251c2631d6p381}, + {0x1.093ffffffb99fp8, 0x1.98b06224611f2p382}, + {0x1.0a3ffffffb99fp8, 0x1.15bba3d909807p384}, + {0x1.0b3ffffffb99fp8, 0x1.797a6e0440f8fp385}, + {0x1.0c3ffffffb99fp8, 0x1.0085e752522ap387}, + {0x1.0d3ffffffb99fp8, 0x1.5ca6a71ef489ep388}, + {0x1.0e3ffffffb99fp8, 0x1.d9dda6826dfc7p389}, + {0x1.0f3ffffffb99fp8, 0x1.420674603ebb2p391}, + {0x1.103ffffffb99fp8, 0x1.b5ad79fec979p392}, + {0x1.113ffffffb99fp8, 0x1.296ecbb3d2db7p394}, + {0x1.123ffffffb99fp8, 0x1.9440c9fa6362ap395}, + {0x1.133ffffffb99fp8, 0x1.12b7ec73193e4p397}, + {0x1.143ffffffb99fp8, 0x1.75618ef49dffep398}, + {0x1.153ffffffb99fp8, 0x1.fb7a3e462b12ap399}, + {0x1.163ffffffb99fp8, 0x1.58dde1b590206p401}, + {0x1.173ffffffb99fp8, 0x1.d4b8f4351faecp402}, + {0x1.183ffffffb99fp8, 0x1.3e87aaa373892p404}, + {0x1.193ffffffb99fp8, 0x1.b0ed5561210d9p405}, + {0x1.1a3ffffffb99fp8, 0x1.263457411e3a5p407}, + {0x1.1b3ffffffb99fp8, 0x1.8fdd8535244cdp408}, + {0x1.1c3ffffffb99fp8, 0x1.0fbc955d170d1p410}, + {0x1.1d3ffffffb99fp8, 0x1.7154125122a86p411}, + {0x1.1e3ffffffb99fp8, 0x1.f5f8270411675p412}, + {0x1.1f3ffffffb99fp8, 0x1.551fa026c4e4cp414}, + {0x1.203ffffffb99fp8, 0x1.cfa28c83a9c15p415}, + {0x1.213ffffffb99fp8, 0x1.3b12972ef5f7ap417}, + {0x1.223ffffffb99fp8, 0x1.ac3a63f8c3fc9p418}, + {0x1.233ffffffb99fp8, 0x1.2302db376285dp420}, + {0x1.243ffffffb99fp8, 0x1.8b867194fa443p421}, + {0x1.253ffffffb99fp8, 0x1.0cc98750c45aep423}, + {0x1.263ffffffb99fp8, 0x1.6d51d877b6f1bp424}, + {0x1.273ffffffb99fp8, 0x1.f0855ddfe3faap425}, + {0x1.283ffffffb99fp8, 0x1.516bc53aea3aap427}, + {0x1.293ffffffb99fp8, 0x1.ca9a47b823396p428}, + {0x1.2a3ffffffb99fp8, 0x1.37a71f0652462p430}, + {0x1.2b3ffffffb99fp8, 0x1.a794811822eb3p431}, + {0x1.2c3ffffffb99fp8, 0x1.1fda3ea9c1a4fp433}, + {0x1.2d3ffffffb99fp8, 0x1.873b6d3965cp434}, + {0x1.2e3ffffffb99fp8, 0x1.09deab488e539p436}, + {0x1.2f3ffffffb99fp8, 0x1.695ac21e2870ep437}, + {0x1.303ffffffb99fp8, 0x1.eb21b852a647cp438}, + {0x1.313ffffffb99fp8, 0x1.4dc2340b86b4cp440}, + {0x1.323ffffffb99fp8, 0x1.c59ffe8afa62cp441}, + {0x1.333ffffffb99fp8, 0x1.3445277810b78p443}, + {0x1.343ffffffb99fp8, 0x1.a2fb88779894fp444}, + {0x1.353ffffffb99fp8, 0x1.1cba68f09f8c5p446}, + {0x1.363ffffffb99fp8, 0x1.82fc56a008db6p447}, + {0x1.373ffffffb99fp8, 0x1.06fbea7eda2dfp449}, + {0x1.383ffffffb99fp8, 0x1.656eb0513614ep450}, + {0x1.393ffffffb99fp8, 0x1.e5cd0c4b86aaap451}, + {0x1.3a3ffffffb99fp8, 0x1.4a22d0026e7ffp453}, + {0x1.3b3ffffffb99fp8, 0x1.c0b38a21c236cp454}, + {0x1.3c3ffffffb99fp8, 0x1.30ec961ce5379p456}, + {0x1.3d3ffffffb99fp8, 0x1.9e6f56344e9dp457}, + {0x1.3e3ffffffb99fp8, 0x1.19a341a8e1ccbp459}, + {0x1.3f3ffffffb99fp8, 0x1.7ec90ca3a1c6dp460}, + {0x1.403ffffffb99fp8, 0x1.04212e6d536d6p462}, + {0x1.413ffffffb99fp8, 0x1.618d84739e91cp463}, + {0x1.423ffffffb99fp8, 0x1.e087302e9607ap464}, + {0x1.433ffffffb99fp8, 0x1.468d7cd8e4417p466}, + {0x1.443ffffffb99fp8, 0x1.bbd4c40e0317cp467}, + {0x1.453ffffffb99fp8, 0x1.2d9d50d6e1436p469}, + {0x1.463ffffffb99fp8, 0x1.99efc6cf25729p470}, + {0x1.473ffffffb99fp8, 0x1.1694b0b33138ap472}, + {0x1.483ffffffb99fp8, 0x1.7aa16e7b0810dp473}, + {0x1.493ffffffb99fp8, 0x1.014e60cc3c10bp475}, + {0x1.4a3ffffffb99fp8, 0x1.5db7203d316b3p476}, + {0x1.4b3ffffffb99fp8, 0x1.db4ffad383047p477}, + {0x1.4c3ffffffb99fp8, 0x1.43021e96bc60ep479}, + {0x1.4d3ffffffb99fp8, 0x1.b703864c0ed74p480}, + {0x1.4e3ffffffb99fp8, 0x1.2a573dd0a80e6p482}, + {0x1.4f3ffffffb99fp8, 0x1.957cb72b9f3f6p483}, + {0x1.503ffffffb99fp8, 0x1.138e9e333d9afp485}, + {0x1.513ffffffb99fp8, 0x1.76855bb82cbcep486}, + {0x1.523ffffffb99fp8, 0x1.fd06d7237d52bp487}, + {0x1.533ffffffb99fp8, 0x1.59eb65b9e296ap489}, + {0x1.543ffffffb99fp8, 0x1.d627438458c6ap490}, + {0x1.553ffffffb99fp8, 0x1.3f80999182b7ap492}, + {0x1.563ffffffb99fp8, 0x1.b23fab41d7fcdp493}, + {0x1.573ffffffb99fp8, 0x1.271a437ca4dd9p495}, + {0x1.583ffffffb99fp8, 0x1.9116048ecdd82p496}, + {0x1.593ffffffb99fp8, 0x1.1090f28f03784p498}, + {0x1.5a3ffffffb99fp8, 0x1.7274b4471d222p499}, + {0x1.5b3ffffffb99fp8, 0x1.f78071e284acfp500}, + {0x1.5c3ffffffb99fp8, 0x1.562a3748e0ae8p502}, + {0x1.5d3ffffffb99fp8, 0x1.d10ce1fc412f2p503}, + {0x1.5e3ffffffb99fp8, 0x1.3c08d26ba29edp505}, + {0x1.5f3ffffffb99fp8, 0x1.ad890dbdcc46ap506}, + {0x1.603ffffffb99fp8, 0x1.23e648944393ap508}, + {0x1.613ffffffb99fp8, 0x1.8cbb8c9e43a63p509}, + {0x1.623ffffffb99fp8, 0x1.0d9b966e13d61p511}, + {0x1.633ffffffb99fp8, 0x1.6e6f586d0888dp512}, + {0x1.643ffffffb99fp8, 0x1.f20966b5813aep513}, + {0x1.653ffffffb99fp8, 0x1.5273779badaf2p515}, + {0x1.663ffffffb99fp8, 0x1.cc00ae664a89p516}, + {0x1.673ffffffb99fp8, 0x1.389aae1391554p518}, + {0x1.683ffffffb99fp8, 0x1.a8df88f5b2588p519}, + {0x1.693ffffffb99fp8, 0x1.20bb34172b66ap521}, + {0x1.6a3ffffffb99fp8, 0x1.886d2d5f07833p522}, + {0x1.6b3ffffffb99fp8, 0x1.0aae72b8de01ep524}, + {0x1.6c3ffffffb99fp8, 0x1.6a7528c7487fep525}, + {0x1.6d3ffffffb99fp8, 0x1.eca18af43a36cp526}, + {0x1.6e3ffffffb99fp8, 0x1.4ec709b53a35fp528}, + {0x1.6f3ffffffb99fp8, 0x1.c702815c30a11p529}, + {0x1.703ffffffb99fp8, 0x1.353611c2fab72p531}, + {0x1.713ffffffb99fp8, 0x1.a442f8858a925p532}, + {0x1.723ffffffb99fp8, 0x1.1d98ed4a7bba3p534}, + {0x1.733ffffffb99fp8, 0x1.842ac5348b7cep535}, + {0x1.743ffffffb99fp8, 0x1.07c97097fb529p537}, + {0x1.753ffffffb99fp8, 0x1.6686064a6be2ap538}, + {0x1.763ffffffb99fp8, 0x1.e748b46cfe14cp539}, + {0x1.773ffffffb99fp8, 0x1.4b24d0e9033c7p541}, + {0x1.783ffffffb99fp8, 0x1.c21233e5293dap542}, + {0x1.793ffffffb99fp8, 0x1.31dae2fdf0407p544}, + {0x1.7a3ffffffb99fp8, 0x1.9fb3386e7303dp545}, + {0x1.7b3ffffffb99fp8, 0x1.1a7f5bb80b183p547}, + {0x1.7c3ffffffb99fp8, 0x1.7ff432dfa67a9p548}, + {0x1.7d3ffffffb99fp8, 0x1.04ec79737cde7p550}, + {0x1.7e3ffffffb99fp8, 0x1.62a1d2414486ep551}, + {0x1.7f3ffffffb99fp8, 0x1.e1feb963592a3p552}, + {0x1.803ffffffb99fp8, 0x1.478cb0da3248p554}, + {0x1.813ffffffb99fp8, 0x1.bd2f9f74b3ecep555}, + {0x1.823ffffffb99fp8, 0x1.2e8907921a545p557}, + {0x1.833ffffffb99fp8, 0x1.9b3025158e763p558}, + {0x1.843ffffffb99fp8, 0x1.176e672da841p560}, + {0x1.853ffffffb99fp8, 0x1.7bc9557d90bb5p561}, + {0x1.863ffffffb99fp8, 0x1.021776f23b20ap563}, + {0x1.873ffffffb99fp8, 0x1.5ec86e4bf78ccp564}, + {0x1.883ffffffb99fp8, 0x1.dcc3708ecfe88p565}, + {0x1.893ffffffb99fp8, 0x1.43fe8d7ac0079p567}, + {0x1.8a3ffffffb99fp8, 0x1.b85a9de96d206p568}, + {0x1.8b3ffffffb99fp8, 0x1.2b406595ebc2fp570}, + {0x1.8c3ffffffb99fp8, 0x1.96b99b42ee81ep571}, + {0x1.8d3ffffffb99fp8, 0x1.1465f7bc5d4f3p573}, + {0x1.8e3ffffffb99fp8, 0x1.77aa0c86e3254p574}, + {0x1.8f3ffffffb99fp8, 0x1.fe94a5f24f127p575}, + {0x1.903ffffffb99fp8, 0x1.5af9bc5f10484p577}, + {0x1.913ffffffb99fp8, 0x1.d796b1199ca0dp578}, + {0x1.923ffffffb99fp8, 0x1.407a4b0a99581p580}, + {0x1.933ffffffb99fp8, 0x1.b393098be48c6p581}, + {0x1.943ffffffb99fp8, 0x1.2800e367d7873p583}, + {0x1.953ffffffb99fp8, 0x1.924f782080a9p584}, + {0x1.963ffffffb99fp8, 0x1.1165f5b7b4e77p586}, + {0x1.973ffffffb99fp8, 0x1.739637ce995dep587}, + {0x1.983ffffffb99fp8, 0x1.f909ef553fe1dp588}, + {0x1.993ffffffb99fp8, 0x1.57359ec295bd8p590}, + {0x1.9a3ffffffb99fp8, 0x1.d278529f70c72p591}, + {0x1.9b3ffffffb99fp8, 0x1.3cffce16c6a9fp593}, + {0x1.9c3ffffffb99fp8, 0x1.aed8bd0d76c2ep594}, + {0x1.9d3ffffffb99fp8, 0x1.24ca67ad88b68p596}, + {0x1.9e3ffffffb99fp8, 0x1.8df19938fe6d4p597}, + {0x1.9f3ffffffb99fp8, 0x1.0e6e49b5016fbp599}, + {0x1.a03ffffffb99fp8, 0x1.6f8db78116a48p600}, + {0x1.a13ffffffb99fp8, 0x1.f38e9ecb87da4p601}, + {0x1.a23ffffffb99fp8, 0x1.537bf81122a93p603}, + {0x1.a33ffffffb99fp8, 0x1.cd682d2c39ab4p604}, + {0x1.a43ffffffb99fp8, 0x1.398efb7895c02p606}, + {0x1.a53ffffffb99fp8, 0x1.aa2b938729ffap607}, + {0x1.a63ffffffb99fp8, 0x1.219cd9531c9cep609}, + {0x1.a73ffffffb99fp8, 0x1.899fdc76e059bp610}, + {0x1.a83ffffffb99fp8, 0x1.0b7edc8aa647ep612}, + {0x1.a93ffffffb99fp8, 0x1.6b906c232d65ep613}, + {0x1.aa3ffffffb99fp8, 0x1.ee22898b97fbep614}, + {0x1.ab3ffffffb99fp8, 0x1.4fccab37000cep616}, + {0x1.ac3ffffffb99fp8, 0x1.c866193ae89dbp617}, + {0x1.ad3ffffffb99fp8, 0x1.3627b854c5c27p619}, + {0x1.ae3ffffffb99fp8, 0x1.a58b68788e1e6p620}, + {0x1.af3ffffffb99fp8, 0x1.1e781f8a5efe5p622}, + {0x1.b03ffffffb99fp8, 0x1.855a202353f77p623}, + {0x1.b13ffffffb99fp8, 0x1.0897974f62fe1p625}, + {0x1.b23ffffffb99fp8, 0x1.679e369129826p626}, + {0x1.b33ffffffb99fp8, 0x1.e8c58542c521dp627}, + {0x1.b43ffffffb99fp8, 0x1.4c279b7142392p629}, + {0x1.b53ffffffb99fp8, 0x1.c371efb43e76ep630}, + {0x1.b63ffffffb99fp8, 0x1.32c9ea1ab59ccp632}, + {0x1.b73ffffffb99fp8, 0x1.a0f817c69fb0ap633}, + {0x1.b83ffffffb99fp8, 0x1.1b5c21ca08788p635}, + {0x1.b93ffffffb99fp8, 0x1.812042e534a64p636}, + {0x1.ba3ffffffb99fp8, 0x1.05b86359a079cp638}, + {0x1.bb3ffffffb99fp8, 0x1.63b6f7fddd3efp639}, + {0x1.bc3ffffffb99fp8, 0x1.e3776813fda8ep640}, + {0x1.bd3ffffffb99fp8, 0x1.488cac4ce84e7p642}, + {0x1.be3ffffffb99fp8, 0x1.be8b89ed9a77dp643}, + {0x1.bf3ffffffb99fp8, 0x1.2f75768394a5p645}, + {0x1.c03ffffffb99fp8, 0x1.9c717dbaae2b8p646}, + {0x1.c13ffffffb99fp8, 0x1.1848c7ccfefe3p648}, + {0x1.c23ffffffb99fp8, 0x1.7cf223c0074fbp649}, + {0x1.c33ffffffb99fp8, 0x1.02e12a3ec0173p651}, + {0x1.c43ffffffb99fp8, 0x1.5fda91f1b0d98p652}, + {0x1.c53ffffffb99fp8, 0x1.de38089682abp653}, + {0x1.c63ffffffb99fp8, 0x1.44fbc1a5fe2ddp655}, + {0x1.c73ffffffb99fp8, 0x1.b9b2c1a7cc7aap656}, + {0x1.c83ffffffb99fp8, 0x1.2c2a43919580dp658}, + {0x1.c93ffffffb99fp8, 0x1.97f7770145248p659}, + {0x1.ca3ffffffb99fp8, 0x1.153df9919867p661}, + {0x1.cb3ffffffb99fp8, 0x1.78cfa212f8edcp662}, + {0x1.cc3ffffffb99fp8, 0x1.0011d5d26caedp664}, + {0x1.cd3ffffffb99fp8, 0x1.5c08e649b4b94p665}, + {0x1.ce3ffffffb99fp8, 0x1.d9073dd4a4c7bp666}, + {0x1.cf3ffffffb99fp8, 0x1.4174bfa6c0d24p668}, + {0x1.d03ffffffb99fp8, 0x1.b4e7710dea691p669}, + {0x1.d13ffffffb99fp8, 0x1.28e8378f2345ap671}, + {0x1.d23ffffffb99fp8, 0x1.9389e0a91894fp672}, + {0x1.d33ffffffb99fp8, 0x1.123b9f58df0dap674}, + {0x1.d43ffffffb99fp8, 0x1.74b89d97dfdd3p675}, + {0x1.d53ffffffb99fp8, 0x1.fa94a04bdb05cp676}, + {0x1.d63ffffffb99fp8, 0x1.5841d736b633cp678}, + {0x1.d73ffffffb99fp8, 0x1.d3e4df4a846ddp679}, + {0x1.d83ffffffb99fp8, 0x1.3df78ac6c50cep681}, + {0x1.d93ffffffb99fp8, 0x1.b02972b428f19p682}, + {0x1.da3ffffffb99fp8, 0x1.25af390e18cbep684}, + {0x1.db3ffffffb99fp8, 0x1.8f289821f41b9p685}, + {0x1.dc3ffffffb99fp8, 0x1.0f41a1a5d8764p687}, + {0x1.dd3ffffffb99fp8, 0x1.70acf6623ff32p688}, + {0x1.de3ffffffb99fp8, 0x1.f515070ef61acp689}, + {0x1.df3ffffffb99fp8, 0x1.5485473c56dfcp691}, + {0x1.e03ffffffb99fp8, 0x1.ced0c4e4d59e4p692}, + {0x1.e13ffffffb99fp8, 0x1.3a8407ca209c6p694}, + {0x1.e23ffffffb99fp8, 0x1.ab78a196b76fdp695}, + {0x1.e33ffffffb99fp8, 0x1.227f2ee6fa305p697}, + {0x1.e43ffffffb99fp8, 0x1.8ad37b3bad33ep698}, + {0x1.e53ffffffb99fp8, 0x1.0c4fe93ccdf88p700}, + {0x1.e63ffffffb99fp8, 0x1.6cac8cde514efp701}, + {0x1.e73ffffffb99fp8, 0x1.efa4b5032b54fp702}, + {0x1.e83ffffffb99fp8, 0x1.50d31930266e8p704}, + {0x1.e93ffffffb99fp8, 0x1.c9cac6ffa71cbp705}, + {0x1.ea3ffffffb99fp8, 0x1.371a1bc09599dp707}, + {0x1.eb3ffffffb99fp8, 0x1.a6d4d9189f018p708}, + {0x1.ec3ffffffb99fp8, 0x1.1f580038307ccp710}, + {0x1.ed3ffffffb99fp8, 0x1.868a6825185b7p711}, + {0x1.ee3ffffffb99fp8, 0x1.09665f229766bp713}, + {0x1.ef3ffffffb99fp8, 0x1.68b741d009e02p714}, + {0x1.f03ffffffb99fp8, 0x1.ea437fb4bc319p715}, + {0x1.f13ffffffb99fp8, 0x1.4d2b3038bf046p717}, + {0x1.f23ffffffb99ep8, 0x1.c4d2be652cea4p718}, + {0x1.f33ffffffb99ep8, 0x1.33b9ac04c0212p720}, + {0x1.f43ffffffb99ep8, 0x1.a23df502a4a3ap721}, + {0x1.f53ffffffb99ep8, 0x1.1c39946547606p723}, + {0x1.f63ffffffb99ep8, 0x1.824d3d6b0103dp724}, + {0x1.f73ffffffb99ep8, 0x1.0684ec9be79c4p726}, + {0x1.f83ffffffb99ep8, 0x1.64ccf65229834p727}, + {0x1.f93ffffffb99ep8, 0x1.e4f13d25df78ap728}, + {0x1.fa3ffffffb99ep8, 0x1.498d6fcce3f5ep730}, + {0x1.fb3ffffffb99ep8, 0x1.bfe8844c8ea89p731}, + {0x1.fc3ffffffb99ep8, 0x1.30629e3b46a18p733}, + {0x1.fd3ffffffb99ep8, 0x1.9db3d1822eed1p734}, + {0x1.fe3ffffffb99ep8, 0x1.1923d3162d5cep736}, + {0x1.ff3ffffffb99ep8, 0x1.7e1bd9f724dbcp737}, + {0x1.001ffffffdccfp9, 0x1.03ab7b2c9b517p739}, + {0x1.009ffffffdccfp9, 0x1.60ed8bd54933ep740}, + {0x1.011ffffffdccfp9, 0x1.dfadc3cd79f32p741}, + {0x1.019ffffffdccfp9, 0x1.45f9bbb2a35d1p743}, + {0x1.021ffffffdccfp9, 0x1.bb0bf258b833ap744}, + {0x1.029ffffffdccfp9, 0x1.2d14d8520baf7p746}, + {0x1.031ffffffdccfp9, 0x1.99364b282dd34p747}, + {0x1.039ffffffdccfp9, 0x1.1616a4367556fp749}, + {0x1.041ffffffdccfp9, 0x1.79f61d0f30fbp750}, + {0x1.049ffffffdccfp9, 0x1.00d9f49709365p752}, + {0x1.051ffffffdccfp9, 0x1.5d18e41eebfc4p753}, + {0x1.059ffffffdccfp9, 0x1.da78ea95d97f9p754}, + {0x1.061ffffffdccfp9, 0x1.426ff7fe794b6p756}, + {0x1.069ffffffdccfp9, 0x1.b63ce2972ea1ep757}, + {0x1.071ffffffdccfp9, 0x1.29d0407f62d33p759}, + {0x1.079ffffffdccfp9, 0x1.94c53ee806803p760}, + {0x1.081ffffffdccfp9, 0x1.1311eff49ae9ap762}, + {0x1.089ffffffdccfp9, 0x1.75dbe653c2ceap763}, + {0x1.091ffffffdccfp9, 0x1.fc2085b6a9375p764}, + {0x1.099ffffffdccfp9, 0x1.594ee148935c8p766}, + {0x1.0a1ffffffdccfp9, 0x1.d55288db74dc3p767}, + {0x1.0a9ffffffdccfp9, 0x1.3ef00912762eap769}, + {0x1.0b1ffffffdccfp9, 0x1.b17b2f7ee7f4ep770}, + {0x1.0b9ffffffdccfp9, 0x1.2694bd41472c4p772}, + {0x1.0c1ffffffdccfp9, 0x1.90608a1681a3ep773}, + {0x1.0c9ffffffdccfp9, 0x1.10159ec1486a4p775}, + {0x1.0d1ffffffdccfp9, 0x1.71cd15bf6b516p776}, + {0x1.0d9ffffffdccfp9, 0x1.f69ca06d83551p777}, + {0x1.0e1ffffffdccfp9, 0x1.558f65bed5d1ap779}, + {0x1.0e9ffffffdccfp9, 0x1.d03a766bae541p780}, + {0x1.0f1ffffffdccfp9, 0x1.3b79d39d672c6p782}, + {0x1.0f9ffffffdccfp9, 0x1.acc6b3ef261e7p783}, + {0x1.101ffffffdccfp9, 0x1.2362355c94574p785}, + {0x1.109ffffffdccfp9, 0x1.8c080a68bcd97p786}, + {0x1.111ffffffdccfp9, 0x1.0d21994e9f02ap788}, + {0x1.119ffffffdccfp9, 0x1.6dc98ba5b51bp789}, + {0x1.121ffffffdccfp9, 0x1.f1280e4617147p790}, + {0x1.129ffffffdccfp9, 0x1.51da544077fa2p792}, + {0x1.131ffffffdccfp9, 0x1.cb308b8399fb7p793}, + {0x1.139ffffffdccfp9, 0x1.380d3c9a00e7ep795}, + {0x1.141ffffffdccfp9, 0x1.a81f4b2e55334p796}, + {0x1.149ffffffdccfp9, 0x1.20388fdc417d5p798}, + {0x1.151ffffffdccfp9, 0x1.87bb9df31efbp799}, + {0x1.159ffffffdccfp9, 0x1.0a35c88f80cbp801}, + {0x1.161ffffffdccfp9, 0x1.69d128b22d25ap802}, + {0x1.169ffffffdccfp9, 0x1.ebc2a4ab78bb5p803}, + {0x1.171ffffffdccfp9, 0x1.4e2f8fdd883d6p805}, + {0x1.179ffffffdccfp9, 0x1.c634a0cec7546p806}, + {0x1.181ffffffdccfp9, 0x1.34aa294e0c99ep808}, + {0x1.189ffffffdccfp9, 0x1.a384d0e8ecc3p809}, + {0x1.191ffffffdccfp9, 0x1.1d17b4109e865p811}, + {0x1.199ffffffdccfp9, 0x1.837b23284f5e9p812}, + {0x1.1a1ffffffdccfp9, 0x1.075215b6dcdc8p814}, + {0x1.1a9ffffffdccfp9, 0x1.65e3cde76e421p815}, + {0x1.1b1ffffffdccfp9, 0x1.e66c397f0e285p816}, + {0x1.1b9ffffffdccfp9, 0x1.4a8efbf67ceccp818}, + {0x1.1c1ffffffdccfp9, 0x1.c1468f660e51bp819}, + {0x1.1c9ffffffdccfp9, 0x1.31507f4997713p821}, + {0x1.1d1ffffffdccfp9, 0x1.9ef72130544cep822}, + {0x1.1d9ffffffdccfp9, 0x1.19ff898e9368dp824}, + {0x1.1e1ffffffdccfp9, 0x1.7f4678d82ff18p825}, + {0x1.1e9ffffffdccfp9, 0x1.04766a36fd582p827}, + {0x1.1f1ffffffdccfp9, 0x1.62015c9e2f34p828}, + {0x1.1f9ffffffdccfp9, 0x1.e124a317460fp829}, + {0x1.201ffffffdccfp9, 0x1.46f87c3b54d8ep831}, + {0x1.209ffffffdccfp9, 0x1.bc6630ce5faecp832}, + {0x1.211ffffffdccfp9, 0x1.2e00246624382p834}, + {0x1.219ffffffdccfp9, 0x1.9a761879cac82p835}, + {0x1.221ffffffdccfp9, 0x1.16eff82ee1911p837}, + {0x1.229ffffffdccfp9, 0x1.7b1d7e2eda2c6p838}, + {0x1.231ffffffdccfp9, 0x1.01a2afc0d75c2p840}, + {0x1.239ffffffdccfp9, 0x1.5e29b684536ep841}, + {0x1.241ffffffdccfp9, 0x1.dbebb83e52c5dp842}, + {0x1.249ffffffdccfp9, 0x1.436bf4aaba53p844}, + {0x1.251ffffffdccfp9, 0x1.b7935ef798935p845}, + {0x1.259ffffffdccfp9, 0x1.2ab8fec5df362p847}, + {0x1.261ffffffdccfp9, 0x1.9601939d5137dp848}, + {0x1.269ffffffdccfp9, 0x1.13e8e80d6759dp850}, + {0x1.271ffffffdccfp9, 0x1.770012b39ed67p851}, + {0x1.279ffffffdccfp9, 0x1.fdada086b9c52p852}, + {0x1.281ffffffdccfp9, 0x1.5a5cbd9bfe665p854}, + {0x1.289ffffffdccfp9, 0x1.d6c15030e89c1p855}, + {0x1.291ffffffdccfp9, 0x1.3fe9499128953p857}, + {0x1.299ffffffdccfp9, 0x1.b2cdf43b59797p858}, + {0x1.2a1ffffffdccfp9, 0x1.277af4d2d449ap860}, + {0x1.2a9ffffffdccfp9, 0x1.91996fd498417p861}, + {0x1.2b1ffffffdccfp9, 0x1.10ea41886590dp863}, + {0x1.2b9ffffffdccfp9, 0x1.72ee16480890ep864}, + {0x1.2c1ffffffdccfp9, 0x1.f8256bd5a1072p865}, + {0x1.2c9ffffffdccfp9, 0x1.569a543aa97d8p867}, + {0x1.2d1ffffffdccfp9, 0x1.d1a5429cffadp868}, + {0x1.2d9ffffffdccfp9, 0x1.3c705f8813894p870}, + {0x1.2e1ffffffdccfp9, 0x1.ae15cb5be04dap871}, + {0x1.2e9ffffffdccfp9, 0x1.2445ed3e27324p873}, + {0x1.2f1ffffffdccfp9, 0x1.8d3d8ab9f0bdep874}, + {0x1.2f9ffffffdccfp9, 0x1.0df3ed3fc701dp876}, + {0x1.301ffffffdccfp9, 0x1.6ee76926e122bp877}, + {0x1.309ffffffdccfp9, 0x1.f2ac9640362cap878}, + {0x1.311ffffffdccfp9, 0x1.52e25d083c6f6p880}, + {0x1.319ffffffdccfp9, 0x1.cc9767a099276p881}, + {0x1.321ffffffdccfp9, 0x1.39011b7511e91p883}, + {0x1.329ffffffdccfp9, 0x1.a96abf82e5bedp884}, + {0x1.331ffffffdccfp9, 0x1.2119ceff4e062p886}, + {0x1.339ffffffdccfp9, 0x1.88edc2473f3cfp887}, + {0x1.341ffffffdccfp9, 0x1.0b05d4146a019p889}, + {0x1.349ffffffdccfp9, 0x1.6aebebe3397ccp890}, + {0x1.351ffffffdccfp9, 0x1.ed42f5104656ep891}, + {0x1.359ffffffdccfp9, 0x1.4f34bafe2847bp893}, + {0x1.361ffffffdccfp9, 0x1.c79797c887ff8p894}, + {0x1.369ffffffdccfp9, 0x1.359b628909b0ap896}, + {0x1.371ffffffdccfp9, 0x1.a4ccac407db6ep897}, + {0x1.379ffffffdccfp9, 0x1.1df681534dcc2p899}, + {0x1.381ffffffdccfp9, 0x1.84a9f4d4f272ap900}, + {0x1.389ffffffdccfp9, 0x1.081fdf276bf44p902}, + {0x1.391ffffffdccfp9, 0x1.66fb7f67746f6p903}, + {0x1.399ffffffdccfp9, 0x1.e7e85e064cb73p904}, + {0x1.3a1ffffffdccfp9, 0x1.4b91516684d28p906}, + {0x1.3a9ffffffdccfp9, 0x1.c2a5ac0f3d022p907}, + {0x1.3b1ffffffdccfp9, 0x1.323f1a3f5edc4p909}, + {0x1.3b9ffffffdccfp9, 0x1.a03b6d89faf11p910}, + {0x1.3c1ffffffdccfp9, 0x1.1adbebbbf9351p912}, + {0x1.3c9ffffffdccfp9, 0x1.80720118fc863p913}, + {0x1.3d1ffffffdccfp9, 0x1.0541f7d976c95p915}, + {0x1.3d9ffffffdccfp9, 0x1.631604f454091p916}, + {0x1.3e1ffffffdccfp9, 0x1.e29ca75828ca4p917}, + {0x1.3e9ffffffdccfp9, 0x1.47f803db3082ep919}, + {0x1.3f1ffffffdccfp9, 0x1.bdc17ddb963f2p920}, + {0x1.3f9ffffffdccfp9, 0x1.2eec285d246c2p922}, + {0x1.401ffffffdccfp9, 0x1.9bb6dfb8d5a7bp923}, + {0x1.409ffffffdccfp9, 0x1.17c9f5ff316ddp925}, + {0x1.411ffffffdccfp9, 0x1.7c45c625cf3bcp926}, + {0x1.419ffffffdccfp9, 0x1.026c07ca1067p928}, + {0x1.421ffffffdccfp9, 0x1.5f3b5e200997dp929}, + {0x1.429ffffffdccfp9, 0x1.dd5fa7afd8289p930}, + {0x1.431ffffffdccfp9, 0x1.4468b644f2c7fp932}, + {0x1.439ffffffdccfp9, 0x1.b8eae6ffb1c26p933}, + {0x1.441ffffffdccfp9, 0x1.2ba272f04fa72p935}, + {0x1.449ffffffdccfp9, 0x1.973edf89954efp936}, + {0x1.451ffffffdccfp9, 0x1.14c088262904bp938}, + {0x1.459ffffffdccfp9, 0x1.782523695aef2p939}, + {0x1.461ffffffdccfp9, 0x1.ff3bf1add8023p940}, + {0x1.469ffffffdccfp9, 0x1.5b6b6cd54844dp942}, + {0x1.471ffffffdccfp9, 0x1.d831362a33e02p943}, + {0x1.479ffffffdccfp9, 0x1.40e34cdaa0c9dp945}, + {0x1.481ffffffdccfp9, 0x1.b421c1b7c391cp946}, + {0x1.489ffffffdccfp9, 0x1.2861e04eed965p948}, + {0x1.491ffffffdccfp9, 0x1.92d34a1abd55p949}, + {0x1.499ffffffdccfp9, 0x1.11bf8a7ca8dc9p951}, + {0x1.4a1ffffffdccfp9, 0x1.740ff8ac10594p952}, + {0x1.4a9ffffffdccfp9, 0x1.f9af6a367aa8cp953}, + {0x1.4b1ffffffdccfp9, 0x1.57a613525a444p955}, + {0x1.4b9ffffffdccfp9, 0x1.d3112a55b14f7p956}, + {0x1.4c1ffffffdccfp9, 0x1.3d67ac204487bp958}, + {0x1.4c9ffffffdccfp9, 0x1.af65e8a8eee76p959}, + {0x1.4d1ffffffdccfp9, 0x1.252a57165ab35p961}, + {0x1.4d9ffffffdccfp9, 0x1.8e73fcebbcdf2p962}, + {0x1.4e1ffffffdccfp9, 0x1.0ec6e5905727p964}, + {0x1.4e9ffffffdccfp9, 0x1.7006260fe518p965}, + {0x1.4f1ffffffdccfp9, 0x1.f4324dde1b853p966}, + {0x1.4f9ffffffdccfp9, 0x1.53eb342838912p968}, + {0x1.501ffffffdccfp9, 0x1.cdff5c312677p969}, + {0x1.509ffffffdccfp9, 0x1.39f5b8e646512p971}, + {0x1.511ffffffdccfp9, 0x1.aab736e0229e8p972}, + {0x1.519ffffffdccfp9, 0x1.21fbbe2a7cc33p974}, + {0x1.521ffffffdccfp9, 0x1.8a20d5dbe17b1p975}, + {0x1.529ffffffdccfp9, 0x1.0bd6823000616p977}, + {0x1.531ffffffdccfp9, 0x1.6c078c0f5af0cp978}, + {0x1.539ffffffdccfp9, 0x1.eec471cd26923p979}, + {0x1.541ffffffdccfp9, 0x1.503ab239a52eep981}, + {0x1.549ffffffdccfp9, 0x1.c8fba42a91b8p982}, + {0x1.551ffffffdccfp9, 0x1.368d584898928p984}, + {0x1.559ffffffdccfp9, 0x1.a61587d0f8cb4p985}, + {0x1.561ffffffdccfp9, 0x1.1ed5fcb4fed8p987}, + {0x1.569ffffffdccfp9, 0x1.85d9b3294cbccp988}, + {0x1.571ffffffdccfp9, 0x1.08ee496ae24e1p990}, + {0x1.579ffffffdccfp9, 0x1.68140b7c89c5cp991}, + {0x1.581ffffffdccfp9, 0x1.e965aba3129a2p992}, + {0x1.589ffffffdccfp9, 0x1.4c9470ba47e91p994}, + {0x1.591ffffffdccfp9, 0x1.c405db1de4f69p995}, + {0x1.599ffffffdccfp9, 0x1.332e6fade5fp997}, + {0x1.5a1ffffffdccfp9, 0x1.a180b7549973p998}, + {0x1.5a9ffffffdccfp9, 0x1.1bb8fa248f731p1000}, + {0x1.5b1ffffffdccfp9, 0x1.819e736fecc0ap1001}, + {0x1.5b9ffffffdccfp9, 0x1.060e248ff8e45p1003}, + {0x1.5c1ffffffdccfp9, 0x1.642b85802c37dp1004}, + {0x1.5c9ffffffdccfp9, 0x1.e415d17516714p1005}, + {0x1.5d1ffffffdccfp9, 0x1.48f8532dcd8aap1007}, + {0x1.5d9ffffffdccfp9, 0x1.bf1dda53d4168p1008}, + {0x1.5e1ffffffdccfp9, 0x1.2fd8e4c6c1a74p1010}, + {0x1.5e9ffffffdccfp9, 0x1.9cf8a1a8a05e1p1011}, + {0x1.5f1ffffffdccfp9, 0x1.18a49e2c20c14p1013}, + {0x1.5f9ffffffdccfp9, 0x1.7d6ef5a877896p1014}, + {0x1.601ffffffdccfp9, 0x1.0335fd2d4d32ap1016}, + {0x1.609ffffffdccfp9, 0x1.604ddb98aeeb6p1017}, + {0x1.611ffffffdccfp9, 0x1.ded4b9cce1c65p1018}, + {0x1.619ffffffdccep9, 0x1.45663d67095d1p1020}, + {0x1.621ffffffdccep9, 0x1.ba437b80a6915p1021}, + {0x1.629ffffffdccep9, 0x1.2c8c9d8cda0c8p1023}, + }; + + for (double[] testCase: testCases) + failures+=testExpm1Case(testCase[0], testCase[1]); + + return failures; + } + + public static void main(String [] argv) { + int failures = 0; + + failures += testExpm1(); + + if (failures > 0) { + System.err.println("Testing expm1 incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:55 2009 +++ new/test/java/lang/StrictMath/HyperbolicTests.java Mon Jan 26 16:12:53 2009 @@ -0,0 +1,280 @@ +/* + * 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 4851625 + * @summary Tests for StrictMath.{sinh, cosh, tanh} + * @author Joseph D. Darcy + */ + +/** + * The tests in ../Math/HyperbolicTests.java test properties that + * should hold for any implementation of the hyperbolic functions + * sinh, cos, and tanh, including the FDLIBM-based ones required by + * the StrictMath class. Therefore, the test cases in + * ../Math/HyperbolicTests.java are run against both the Math and + * StrictMath versions of the hyperbolic methods. The role of this + * test is to verify that the FDLIBM algorithms are being used by + * running golden file tests on values that may vary from one + * conforming implementation of the hyperbolics to another. + */ + +public class HyperbolicTests { + private HyperbolicTests(){} + + static int testSinhCase(double input, double expected) { + return Tests.test("StrictMath.sinh(double)", input, + StrictMath.sinh(input), expected); + } + + static int testCoshCase(double input, double expected) { + return Tests.test("StrictMath.cosh(double)", input, + StrictMath.cosh(input), expected); + } + + static int testTanhCase(double input, double expected) { + return Tests.test("StrictMath.tanh(double)", input, + StrictMath.tanh(input), expected); + } + + static int testSinh() { + int failures = 0; + double [][] testCases = { + {0x1.5798ee2308c3ap-27, 0x1.5798ee2308c3bp-27}, + {0x1.ffffffffffff8p-26, 0x1.ffffffffffffap-26}, + {0x1.ffffffffffffep-26, 0x1.0p-25}, + {0x1.ffffffffffff8p-25, 0x1.ffffffffffffep-25}, + {0x1.ffffffffffffap-25, 0x1.0p-24}, + {0x1.ad7f29abcaf47p-24, 0x1.ad7f29abcaf53p-24}, + {0x1.ad7f29abcaf48p-24, 0x1.ad7f29abcaf54p-24}, + {0x1.fffffffffffeap-24, 0x1.0p-23}, + {0x1.ffffffffffff8p-24, 0x1.0000000000007p-23}, + {0x1.fffffffffffaap-23, 0x1.0p-22}, + {0x1.ffffffffffff8p-23, 0x1.0000000000027p-22}, + {0x1.ffffffffffeaap-22, 0x1.0p-21}, + {0x1.ffffffffffff8p-22, 0x1.00000000000a7p-21}, + {0x1.ffffffffffaaap-21, 0x1.0p-20}, + {0x1.ffffffffffff8p-21, 0x1.00000000002a7p-20}, + {0x1.0c6f7a0b5ed8cp-20, 0x1.0c6f7a0b5f09fp-20}, + {0x1.0c6f7a0b5ed8dp-20, 0x1.0c6f7a0b5f0ap-20}, + {0x1.fffffffffeaaap-20, 0x1.0p-19}, + {0x1.ffffffffffff8p-20, 0x1.0000000000aa7p-19}, + {0x1.ffffffffffff8p-19, 0x1.0000000002aa7p-18}, + {0x1.ffffffffffff7p-18, 0x1.000000000aaa6p-17}, + {0x1.4f8b588e368d9p-17, 0x1.4f8b588e4e928p-17}, + {0x1.ffffffffffffep-17, 0x1.000000002aaa9p-16}, + {0x1.0p-16, 0x1.000000002aaaap-16}, + {0x1.fffffffffffffp-16, 0x1.00000000aaaabp-15}, + {0x1.fffffffffeaaap-15, 0x1.00000002aap-14}, + {0x1.ffffffffffffep-15, 0x1.00000002aaaa9p-14}, + {0x1.0p-14, 0x1.00000002aaaaap-14}, + {0x1.a36e2eb1c3dd4p-14, 0x1.a36e2ebd7e43ap-14}, + {0x1.a36e2eb1c3f8cp-14, 0x1.a36e2ebd7e5f1p-14}, + {0x1.a36e2eb1c432cp-14, 0x1.a36e2ebd7e991p-14}, + {0x1.fffffffffffffp-14, 0x1.0000000aaaaabp-13}, + {0x1.ffffffffffffep-13, 0x1.0000002aaaaa9p-12}, + {0x1.0p-12, 0x1.0000002aaaaaap-12}, + {0x1.ffffffffff7f9p-12, 0x1.000000aaaa6a9p-11}, + {0x1.fffffffffffffp-12, 0x1.000000aaaaaadp-11}, + {0x1.ffffffffffffep-11, 0x1.000002aaaaacbp-10}, + {0x1.0p-10, 0x1.000002aaaaaccp-10}, + {0x1.0624dd2f1a79p-10, 0x1.0624e00c1c776p-10}, + {0x1.0624dd2f1a8c9p-10, 0x1.0624e00c1c8bp-10}, + {0x1.0624dd2f1a9fcp-10, 0x1.0624e00c1c9e3p-10}, + {0x1.ffffffffffffep-10, 0x1.00000aaaaaccbp-9}, + {0x1.0p-9, 0x1.00000aaaaacccp-9}, + {0x1.ffffffffffe4ap-9, 0x1.00002aaaacbf2p-8}, + {0x1.fffffffffffffp-9, 0x1.00002aaaacccdp-8}, + {0x1.fffffffffff9dp-8, 0x1.0000aaaaccc9bp-7}, + {0x1.ffffffffffffep-8, 0x1.0000aaaacccccp-7}, + {0x1.0p-7, 0x1.0000aaaaccccdp-7}, + {0x1.47ae147ae146fp-7, 0x1.47af7a654e9e2p-7}, + {0x1.47ae147ae147ap-7, 0x1.47af7a654e9eep-7}, + {0x1.47ae147ae147bp-7, 0x1.47af7a654e9efp-7}, + {0x1.fffffffffffb6p-7, 0x1.0002aaaccccb4p-6}, + {0x1.fffffffffffcap-7, 0x1.0002aaaccccbep-6}, + {0x1.ffffffffffff7p-7, 0x1.0002aaaccccd5p-6}, + {0x1.fffffffffffe9p-6, 0x1.000aaacccd001p-5}, + {0x1.ffffffffffff7p-6, 0x1.000aaacccd008p-5}, + {0x1.fffffffffffffp-6, 0x1.000aaacccd00dp-5}, + {0x1.ffffffffffff6p-5, 0x1.002aacccd9cd7p-4}, + {0x1.ffffffffffff8p-5, 0x1.002aacccd9cd9p-4}, + {0x1.0p-4, 0x1.002aacccd9cddp-4}, + {0x1.9999999999995p-4, 0x1.9a487337b59afp-4}, + {0x1.9999999999996p-4, 0x1.9a487337b59afp-4}, + {0x1.9999999999998p-4, 0x1.9a487337b59b1p-4}, + {0x1.ffffffffffffap-4, 0x1.00aaccd00d2edp-3}, + {0x1.ffffffffffffcp-4, 0x1.00aaccd00d2efp-3}, + {0x1.ffffffffffff3p-3, 0x1.02accd9d080fbp-2}, + {0x1.ffffffffffffdp-3, 0x1.02accd9d08101p-2}, + {0x1.fffffffffffffp-3, 0x1.02accd9d08101p-2}, + {0x1.fffffffffffecp-2, 0x1.0acd00fe63b8cp-1}, + {0x1.ffffffffffffcp-2, 0x1.0acd00fe63b94p-1}, + {0x1.0p-1, 0x1.0acd00fe63b97p-1}, + {0x1.ffffffffffff6p-1, 0x1.2cd9fc44eb97ap0}, + {0x1.ffffffffffffep-1, 0x1.2cd9fc44eb981p0}, + {0x1.fffffffffffffp0, 0x1.d03cf63b6e19ep1}, + {0x1.0p1, 0x1.d03cf63b6e1ap1}, + {0x1.fffffffffffffp1, 0x1.b4a380370362dp4}, + {0x1.0p2, 0x1.b4a380370363p4}, + {0x1.ffffffffffffcp2, 0x1.749ea514eca4ep10}, + {0x1.0p3, 0x1.749ea514eca66p10}, + {0x1.fffffffffffffp3, 0x1.0f2ebd0a7ffdcp22}, + {0x1.0p4, 0x1.0f2ebd0a7ffe4p22}, + {0x1.fffffffffff68p4, 0x1.1f43fcc4b5b83p45}, + {0x1.fffffffffffd4p4, 0x1.1f43fcc4b6316p45}, + {0x1.0p5, 0x1.1f43fcc4b662cp45}, + }; + + for (double[] testCase: testCases) + failures+=testSinhCase(testCase[0], testCase[1]); + + return failures; + } + + static int testCosh() { + int failures = 0; + double [][] testCases = { + {0x1.fffffffffb49fp-8, 0x1.00020000aaaabp0}, + {0x1.47ae147ae0e45p-7, 0x1.000346de27853p0}, + {0x1.fffffffffd9f3p-7, 0x1.0008000aaab05p0}, + {0x1.ffffffffff9f1p-7, 0x1.0008000aaab05p0}, + {0x1.fffffffffe27dp-6, 0x1.002000aaac169p0}, + {0x1.ffffffffff27bp-6, 0x1.002000aaac16bp0}, + {0x1.ffffffffffb9cp-5, 0x1.00800aab05b1ep0}, + {0x1.ffffffffffd9dp-5, 0x1.00800aab05b1fp0}, + {0x1.9999999999368p-4, 0x1.0147f40224b2ep0}, + {0x1.9999999999727p-4, 0x1.0147f40224b35p0}, + {0x1.ffffffffffed1p-4, 0x1.0200aac16db6cp0}, + {0x1.fffffffffffd1p-4, 0x1.0200aac16db6ep0}, + {0x1.ffffffffffeb4p-3, 0x1.080ab05ca613bp0}, + {0x1.ffffffffffff2p-3, 0x1.080ab05ca6146p0}, + {0x1.ffffffffffff3p-2, 0x1.20ac1862ae8cep0}, + {0x1.ffffffffffff9p-2, 0x1.20ac1862ae8dp0}, + {0x1.0p0, 0x1.8b07551d9f551p0}, + {0x1.ffffffffffffbp0, 0x1.e18fa0df2d9b3p1}, + {0x1.ffffffffffffep0, 0x1.e18fa0df2d9b8p1}, + {0x1.fffffffffffffp0, 0x1.e18fa0df2d9bap1}, + {0x1.ffffffffffff9p1, 0x1.b4ee858de3e68p4}, + {0x1.ffffffffffffep1, 0x1.b4ee858de3e7ap4}, + {0x1.fffffffffffffp1, 0x1.b4ee858de3e7dp4}, + {0x1.ffffffffffffcp2, 0x1.749eaa93f4e5ep10}, + {0x1.ffffffffffffdp2, 0x1.749eaa93f4e64p10}, + {0x1.0p3, 0x1.749eaa93f4e76p10}, + {0x1.fffffffffff6fp3, 0x1.0f2ebd0a7fb9p22}, + {0x1.0p4, 0x1.0f2ebd0a8005cp22}, + {0x1.fffffffffffd4p4, 0x1.1f43fcc4b6316p45}, + {0x1.0p5, 0x1.1f43fcc4b662cp45}, + }; + + for (double[] testCase: testCases) + failures+=testCoshCase(testCase[0], testCase[1]); + + return failures; + } + + static int testTanh() { + int failures = 0; + double [][] testCases = { + {0x1.5798ee2308c36p-27, 0x1.5798ee2308c36p-27}, + {0x1.ffffffffffffep-26, 0x1.ffffffffffffbp-26}, + {0x1.ffffffffffffep-25, 0x1.ffffffffffff3p-25}, + {0x1.ad7f29abcaf47p-24, 0x1.ad7f29abcaf2dp-24}, + {0x1.ad7f29abcaf48p-24, 0x1.ad7f29abcaf2ep-24}, + {0x1.ffffffffffffep-24, 0x1.fffffffffffd3p-24}, + {0x1.ffffffffffffep-23, 0x1.fffffffffff53p-23}, + {0x1.ffffffffffffep-22, 0x1.ffffffffffd53p-22}, + {0x1.ffffffffffffep-21, 0x1.ffffffffff553p-21}, + {0x1.0c6f7a0b5ed8dp-20, 0x1.0c6f7a0b5e767p-20}, + {0x1.ffffffffffffep-20, 0x1.fffffffffd553p-20}, + {0x1.ffffffffffffep-19, 0x1.fffffffff5553p-19}, + {0x1.fffffffffffffp-18, 0x1.ffffffffd5555p-18}, + {0x1.0p-17, 0x1.ffffffffd5556p-18}, + {0x1.4f8b588e368edp-17, 0x1.4f8b588e0685p-17}, + {0x1.fffffffffffffp-17, 0x1.ffffffff55554p-17}, + {0x1.fffffffffffffp-16, 0x1.fffffffd55555p-16}, + {0x1.0p-15, 0x1.fffffffd55556p-16}, + {0x1.fffffffffe5ddp-15, 0x1.fffffff553b33p-15}, + {0x1.fffffffffffffp-15, 0x1.fffffff555554p-15}, + {0x1.a36e2eb1c432dp-14, 0x1.a36e2e9a4f663p-14}, + {0x1.ffffffffffffep-14, 0x1.ffffffd555553p-14}, + {0x1.0p-13, 0x1.ffffffd555555p-14}, + {0x1.ffffffffffd51p-13, 0x1.ffffff55552aap-13}, + {0x1.fffffffffffffp-13, 0x1.ffffff5555559p-13}, + {0x1.ffffffffffffep-12, 0x1.fffffd5555597p-12}, + {0x1.0p-11, 0x1.fffffd5555599p-12}, + {0x1.fffffffffff1p-11, 0x1.fffff555558a9p-11}, + {0x1.0p-10, 0x1.fffff5555599ap-11}, + {0x1.0624dd2f1a9c6p-10, 0x1.0624d77516cabp-10}, + {0x1.0624dd2f1a9f8p-10, 0x1.0624d77516cdep-10}, + {0x1.fffffffffffddp-10, 0x1.ffffd55559976p-10}, + {0x1.fffffffffffffp-10, 0x1.ffffd55559999p-10}, + {0x1.ffffffffffffcp-9, 0x1.ffff555599993p-9}, + {0x1.ffffffffffffep-9, 0x1.ffff555599996p-9}, + {0x1.ffffffffffff8p-8, 0x1.fffd555999924p-8}, + {0x1.ffffffffffffep-8, 0x1.fffd555999929p-8}, + {0x1.47ae147ae1458p-7, 0x1.47ab48ae4593cp-7}, + {0x1.47ae147ae1464p-7, 0x1.47ab48ae45947p-7}, + {0x1.ffffffffffffep-7, 0x1.fff5559997df6p-7}, + {0x1.fffffffffffffp-7, 0x1.fff5559997df8p-7}, + {0x1.ffffffffffff9p-6, 0x1.ffd559992b1d8p-6}, + {0x1.ffffffffffffep-6, 0x1.ffd559992b1dcp-6}, + {0x1.ffffffffffff9p-5, 0x1.ff55997e030d1p-5}, + {0x1.fffffffffffffp-5, 0x1.ff55997e030d6p-5}, + {0x1.9999999999996p-4, 0x1.983d7795f4137p-4}, + {0x1.9999999999997p-4, 0x1.983d7795f4137p-4}, + {0x1.fffffffffffffp-4, 0x1.fd5992bc4b834p-4}, + {0x1.0p-3, 0x1.fd5992bc4b834p-4}, + {0x1.fffffffffffffp-3, 0x1.f597ea69a1c86p-3}, + {0x1.ffffffffffffcp-2, 0x1.d9353d7568aefp-2}, + {0x1.ffffffffffffep-2, 0x1.d9353d7568af3p-2}, + {0x1.ffffffffffffbp-1, 0x1.85efab514f393p-1}, + {0x1.ffffffffffffep-1, 0x1.85efab514f393p-1}, + {0x1.fffffffffffd3p0, 0x1.ed9505e1bc3cep-1}, + {0x1.fffffffffffe1p0, 0x1.ed9505e1bc3cfp-1}, + {0x1.ffffffffffed8p1, 0x1.ffa81708a0b4p-1}, + {0x1.fffffffffff92p1, 0x1.ffa81708a0b41p-1}, + }; + + for (double[] testCase: testCases) + failures+=testTanhCase(testCase[0], testCase[1]); + + return failures; + } + + + public static void main(String [] argv) { + int failures = 0; + + failures += testSinh(); + failures += testCosh(); + failures += testTanh(); + + if (failures > 0) { + System.err.println("Testing the hyperbolics incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:57 2009 +++ new/test/java/lang/StrictMath/HypotTests.java Mon Jan 26 16:12:56 2009 @@ -0,0 +1,633 @@ +/* + * 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 4851638 + * @summary Tests for StrictMath.hypot + * @author Joseph D. Darcy + */ + +/** + * The tests in ../Math/HypotTests.java test properties that should + * hold for any hypot implementation, including the FDLIBM-based one + * required for StrictMath.hypot. Therefore, the test cases in + * ../Math/HypotTests.java are run against both the Math and + * StrictMath versions of hypot. The role of this test is to verify + * that the FDLIBM hypot algorithm is being used by running golden + * file tests on values that may vary from one conforming hypot + * implementation to another. + */ + +public class HypotTests { + private HypotTests(){} + + static int testHypotCase(double input1, double input2, double expected) { + return Tests.test("StrictMath.hypot(double)", input1, input2, + StrictMath.hypot(input1, input2), expected); + } + + static int testHypot() { + int failures = 0; + + double [][] testCases = { + {0x1.0p0, 0x1.ffffffffffab5p-1, 0x1.6a09e667f39edp0}, + {0x1.0p0, 0x1.ffffffffffffbp0, 0x1.1e3779b97f4a6p1}, + {0x1.0p0, 0x1.7ffffffffffffp1, 0x1.94c583ada5b51p1}, + {0x1.0p0, 0x1.ffffffffffffdp1, 0x1.07e0f66afed06p2}, + {0x1.0p0, 0x1.3fffffffffffdp2, 0x1.465655f122ff3p2}, + {0x1.0p0, 0x1.4p2, 0x1.465655f122ff6p2}, + {0x1.0p0, 0x1.7ffffffffffffp2, 0x1.854bfb363dc38p2}, + {0x1.0p0, 0x1.8p2, 0x1.854bfb363dc39p2}, + {0x1.0p0, 0x1.bfffffffffffep2, 0x1.c48c6001f0abdp2}, + {0x1.0p0, 0x1.fffffffffffffp2, 0x1.01fe03f61badp3}, + {0x1.0p0, 0x1.1fffffffffffap3, 0x1.21c5b70d9f81dp3}, + {0x1.0p0, 0x1.3ffffffffffe5p3, 0x1.419894c2329d5p3}, + {0x1.0p0, 0x1.3ffffffffffe7p3, 0x1.419894c2329d8p3}, + {0x1.0p0, 0x1.5ffffffffff7ep3, 0x1.617398f2aa9c6p3}, + {0x1.0p0, 0x1.5ffffffffff8dp3, 0x1.617398f2aa9d5p3}, + {0x1.0p0, 0x1.7ffffffffff9bp3, 0x1.8154be27734c1p3}, + {0x1.0p0, 0x1.8p3, 0x1.8154be2773526p3}, + {0x1.0p0, 0x1.9fffffffffff4p3, 0x1.a13a9cb996644p3}, + {0x1.0p0, 0x1.9ffffffffffffp3, 0x1.a13a9cb99664fp3}, + {0x1.0p0, 0x1.bfffffffffffep3, 0x1.c12432fec0327p3}, + {0x1.0p0, 0x1.cp3, 0x1.c12432fec0329p3}, + {0x1.0p0, 0x1.dffffffffffbcp3, 0x1.e110c39105f6bp3}, + {0x1.0p0, 0x1.ep3, 0x1.e110c39105fafp3}, + {0x1.0p0, 0x1.ffffffffffeafp3, 0x1.007fe00ff5fc8p4}, + {0x1.0p0, 0x1.0fffffffffff4p4, 0x1.10785dd689a1cp4}, + {0x1.0p0, 0x1.0fffffffffffbp4, 0x1.10785dd689a23p4}, + {0x1.0p0, 0x1.1ffffffffff92p4, 0x1.2071b0abcd7cap4}, + {0x1.0p0, 0x1.1ffffffffff99p4, 0x1.2071b0abcd7d1p4}, + {0x1.0p0, 0x1.2fffffffffffcp4, 0x1.306bb705ae7bfp4}, + {0x1.0p0, 0x1.2ffffffffffffp4, 0x1.306bb705ae7c3p4}, + {0x1.0p0, 0x1.3fffffffffffdp4, 0x1.4066560954a8bp4}, + {0x1.0p0, 0x1.4fffffffffe14p4, 0x1.506177f548fcfp4}, + {0x1.0p0, 0x1.5p4, 0x1.506177f5491bbp4}, + {0x1.0p0, 0x1.5fffffffffffdp4, 0x1.605d0af9d3a42p4}, + {0x1.0p0, 0x1.5fffffffffffep4, 0x1.605d0af9d3a42p4}, + {0x1.0p0, 0x1.6fffffffffff8p4, 0x1.7059005e2c015p4}, + {0x1.0p0, 0x1.6ffffffffffffp4, 0x1.7059005e2c01dp4}, + {0x1.0p0, 0x1.7fffffffffffdp4, 0x1.80554bdc2dc4dp4}, + {0x1.0p0, 0x1.7ffffffffffffp4, 0x1.80554bdc2dc4ep4}, + {0x1.0p0, 0x1.8fffffffffe68p4, 0x1.9051e3235a2cp4}, + {0x1.0p0, 0x1.9p4, 0x1.9051e3235a458p4}, + {0x1.0p0, 0x1.9fffffffffff4p4, 0x1.a04ebd789d00cp4}, + {0x1.0p0, 0x1.ap4, 0x1.a04ebd789d019p4}, + {0x1.0p0, 0x1.afffffffffed8p4, 0x1.b04bd36b639fbp4}, + {0x1.0p0, 0x1.affffffffff43p4, 0x1.b04bd36b63a66p4}, + {0x1.0p0, 0x1.bfffffffffe3ep4, 0x1.c0491e9ab90fdp4}, + {0x1.0p0, 0x1.cp4, 0x1.c0491e9ab92bfp4}, + {0x1.0p0, 0x1.cfffffffffed8p4, 0x1.d0469986884d6p4}, + {0x1.0p0, 0x1.cfffffffffee8p4, 0x1.d0469986884e5p4}, + {0x1.0p0, 0x1.dfffffffffe5cp4, 0x1.e0443f6a33104p4}, + {0x1.0p0, 0x1.dffffffffffffp4, 0x1.e0443f6a332a7p4}, + {0x1.0p0, 0x1.efffffffffff8p4, 0x1.f0420c1e63084p4}, + {0x1.0p0, 0x1.fp4, 0x1.f0420c1e6308dp4}, + {0x1.0p0, 0x1.ffffffffffffdp4, 0x1.001ffe003ff5fp5}, + {0x1.0p0, 0x1.07ffffffffed8p5, 0x1.081f05ef4d755p5}, + {0x1.0p0, 0x1.07ffffffffee8p5, 0x1.081f05ef4d764p5}, + {0x1.0p0, 0x1.0fffffffffff4p5, 0x1.101e1c7371c6bp5}, + {0x1.0p0, 0x1.0fffffffffffbp5, 0x1.101e1c7371c72p5}, + {0x1.0p0, 0x1.17ffffffffff8p5, 0x1.181d404cf7f51p5}, + {0x1.0p0, 0x1.17ffffffffffdp5, 0x1.181d404cf7f56p5}, + {0x1.0p0, 0x1.1fffffffffbf2p5, 0x1.201c705fa7a27p5}, + {0x1.0p0, 0x1.1fffffffffc65p5, 0x1.201c705fa7a9ap5}, + {0x1.0p0, 0x1.27ffffffffe08p5, 0x1.281babadfba01p5}, + {0x1.0p0, 0x1.28p5, 0x1.281babadfbbf9p5}, + {0x1.0p0, 0x1.2ffffffffff64p5, 0x1.301af15517357p5}, + {0x1.0p0, 0x1.2ffffffffff6cp5, 0x1.301af1551735ep5}, + {0x1.0p0, 0x1.37ffffffffc78p5, 0x1.381a40895d3f5p5}, + {0x1.0p0, 0x1.37ffffffffc88p5, 0x1.381a40895d406p5}, + {0x1.0p0, 0x1.3fffffffffffdp5, 0x1.4019989389b2dp5}, + {0x1.0p0, 0x1.4p5, 0x1.4019989389b3p5}, + {0x1.0p0, 0x1.47fffffffffe8p5, 0x1.4818f8ce34e19p5}, + {0x1.0p0, 0x1.47ffffffffffap5, 0x1.4818f8ce34e2cp5}, + {0x1.0p0, 0x1.4fffffffffa64p5, 0x1.501860a3b54bep5}, + {0x1.0p0, 0x1.4fffffffffe47p5, 0x1.501860a3b58a1p5}, + {0x1.0p0, 0x1.57ffffffffff8p5, 0x1.5817cf8c4c199p5}, + {0x1.0p0, 0x1.57fffffffffffp5, 0x1.5817cf8c4c1ap5}, + {0x1.0p0, 0x1.5fffffffffbeep5, 0x1.6017450c8d3e7p5}, + {0x1.0p0, 0x1.6p5, 0x1.6017450c8d7f9p5}, + {0x1.0p0, 0x1.67fffffffffe8p5, 0x1.6816c0b405afp5}, + {0x1.0p0, 0x1.68p5, 0x1.6816c0b405b09p5}, + {0x1.0p0, 0x1.6fffffffffb78p5, 0x1.7016421c06043p5}, + {0x1.0p0, 0x1.7p5, 0x1.7016421c064cbp5}, + {0x1.0p0, 0x1.77ffffffffffp5, 0x1.7815c8e69cc37p5}, + {0x1.0p0, 0x1.77ffffffffffcp5, 0x1.7815c8e69cc43p5}, + {0x1.0p0, 0x1.7ffffffffffffp5, 0x1.801554bda99c5p5}, + {0x1.0p0, 0x1.87fffffffffdp5, 0x1.8814e55214271p5}, + {0x1.0p0, 0x1.87ffffffffffcp5, 0x1.8814e5521429ep5}, + {0x1.0p0, 0x1.8ffffffffffe8p5, 0x1.90147a5b16ce5p5}, + {0x1.0p0, 0x1.8fffffffffffcp5, 0x1.90147a5b16cfap5}, + {0x1.0p0, 0x1.97ffffffffffp5, 0x1.98141395a0592p5}, + {0x1.0p0, 0x1.97fffffffffffp5, 0x1.98141395a05a1p5}, + {0x1.0p0, 0x1.9fffffffff8f4p5, 0x1.a013b0c3c7377p5}, + {0x1.0p0, 0x1.9fffffffffb18p5, 0x1.a013b0c3c759bp5}, + {0x1.0p0, 0x1.a7fffffffffdp5, 0x1.a81351ac4f317p5}, + {0x1.0p0, 0x1.a7ffffffffffp5, 0x1.a81351ac4f338p5}, + {0x1.0p0, 0x1.afffffffff698p5, 0x1.b012f61a35d98p5}, + {0x1.0p0, 0x1.bp5, 0x1.b012f61a367p5}, + {0x1.0p0, 0x1.b7ffffffff85p5, 0x1.b8129ddc56b26p5}, + {0x1.0p0, 0x1.b7ffffffff87p5, 0x1.b8129ddc56b45p5}, + {0x1.0p0, 0x1.bfffffffffffdp5, 0x1.c01248c50d99cp5}, + {0x1.0p0, 0x1.bfffffffffffep5, 0x1.c01248c50d99cp5}, + {0x1.0p0, 0x1.c7ffffffffedp5, 0x1.c811f6a9e9676p5}, + {0x1.0p0, 0x1.c8p5, 0x1.c811f6a9e97a6p5}, + {0x1.0p0, 0x1.cffffffffffe8p5, 0x1.d011a7636789ep5}, + {0x1.0p0, 0x1.d7ffffffffffp5, 0x1.d8115accb20f3p5}, + {0x1.0p0, 0x1.d8p5, 0x1.d8115accb2103p5}, + {0x1.0p0, 0x1.dfffffffffebcp5, 0x1.e01110c367a41p5}, + {0x1.0p0, 0x1.ep5, 0x1.e01110c367b85p5}, + {0x1.0p0, 0x1.e7fffffffffdp5, 0x1.e810c927681fap5}, + {0x1.0p0, 0x1.e8p5, 0x1.e810c9276822ap5}, + {0x1.0p0, 0x1.efffffffff7f8p5, 0x1.f01083daa4dadp5}, + {0x1.0p0, 0x1.fp5, 0x1.f01083daa55b5p5}, + {0x1.0p0, 0x1.f7ffffffffffp5, 0x1.f81040c0f9c6p5}, + {0x1.0p0, 0x1.f8p5, 0x1.f81040c0f9c71p5}, + {0x1.0p0, 0x1.fffffffffffffp5, 0x1.0007ffe000fffp6}, + {0x1.0p0, 0x1.03fffffffffdp6, 0x1.0407e05f7d188p6}, + {0x1.0p0, 0x1.03ffffffffffbp6, 0x1.0407e05f7d1b4p6}, + {0x1.0p0, 0x1.07ffffffff7f8p6, 0x1.0807c1d34edd5p6}, + {0x1.0p0, 0x1.07ffffffff808p6, 0x1.0807c1d34ede4p6}, + {0x1.0p0, 0x1.0bffffffff65p6, 0x1.0c07a430870e5p6}, + {0x1.0p0, 0x1.0bffffffff67p6, 0x1.0c07a43087104p6}, + {0x1.0p0, 0x1.0fffffffffc54p6, 0x1.1007876cda509p6}, + {0x1.0p0, 0x1.0fffffffffe0dp6, 0x1.1007876cda6c2p6}, + {0x1.0p0, 0x1.13fffffffffdp6, 0x1.14076b7e954b4p6}, + {0x1.0p0, 0x1.13ffffffffffep6, 0x1.14076b7e954e3p6}, + {0x1.0p0, 0x1.17ffffffffff8p6, 0x1.1807505c9310dp6}, + {0x1.0p0, 0x1.18p6, 0x1.1807505c93116p6}, + {0x1.0p0, 0x1.1bfffffffecbp6, 0x1.1c0735fe3197ap6}, + {0x1.0p0, 0x1.1bffffffff1dbp6, 0x1.1c0735fe31ea5p6}, + {0x1.0p0, 0x1.1ffffffffebcap6, 0x1.20071c5b4ce64p6}, + {0x1.0p0, 0x1.1fffffffffaf1p6, 0x1.20071c5b4dd8bp6}, + {0x1.0p0, 0x1.23ffffffff83p6, 0x1.2407036c309fdp6}, + {0x1.0p0, 0x1.23ffffffff85p6, 0x1.2407036c30a1cp6}, + {0x1.0p0, 0x1.27ffffffffba8p6, 0x1.2806eb2991e76p6}, + {0x1.0p0, 0x1.28p6, 0x1.2806eb29922cep6}, + {0x1.0p0, 0x1.2bfffffffff7p6, 0x1.2c06d38c8b4ffp6}, + {0x1.0p0, 0x1.2bfffffffff9p6, 0x1.2c06d38c8b52p6}, + {0x1.0p0, 0x1.2fffffffffff4p6, 0x1.3006bc8e938c8p6}, + {0x1.0p0, 0x1.2fffffffffffcp6, 0x1.3006bc8e938cfp6}, + {0x1.0p0, 0x1.33ffffffff87p6, 0x1.3406a6297821ep6}, + {0x1.0p0, 0x1.33ffffffff89p6, 0x1.3406a6297823dp6}, + {0x1.0p0, 0x1.37ffffffff9d8p6, 0x1.380690575943dp6}, + {0x1.0p0, 0x1.37ffffffff9eap6, 0x1.380690575944fp6}, + {0x1.0p0, 0x1.3bffffffffffp6, 0x1.3c067b12a2013p6}, + {0x1.0p0, 0x1.3cp6, 0x1.3c067b12a2024p6}, + {0x1.0p0, 0x1.3fffffffffe19p6, 0x1.40066656044ep6}, + {0x1.0p0, 0x1.4p6, 0x1.40066656046c7p6}, + {0x1.0p0, 0x1.43ffffffff1dp6, 0x1.4406521c75c3p6}, + {0x1.0p0, 0x1.43ffffffffccfp6, 0x1.4406521c7672fp6}, + {0x1.0p0, 0x1.47ffffffff8a8p6, 0x1.48063e612ce7ap6}, + {0x1.0p0, 0x1.47ffffffffcb9p6, 0x1.48063e612d28bp6}, + {0x1.0p0, 0x1.4bfffffffe1fp6, 0x1.4c062b1f96823p6}, + {0x1.0p0, 0x1.4cp6, 0x1.4c062b1f98633p6}, + {0x1.0p0, 0x1.4ffffffffde04p6, 0x1.500618535d07dp6}, + {0x1.0p0, 0x1.5p6, 0x1.500618535f279p6}, + {0x1.0p0, 0x1.53fffffffef1p6, 0x1.540605f85c637p6}, + {0x1.0p0, 0x1.53ffffffffdf3p6, 0x1.540605f85d51ap6}, + {0x1.0p0, 0x1.57ffffffffff8p6, 0x1.5805f40aa0595p6}, + {0x1.0p0, 0x1.5bffffffffffp6, 0x1.5c05e286636b5p6}, + {0x1.0p0, 0x1.5bfffffffffffp6, 0x1.5c05e286636c4p6}, + {0x1.0p0, 0x1.5ffffffffd9cep6, 0x1.6005d1680baa2p6}, + {0x1.0p0, 0x1.5fffffffff873p6, 0x1.6005d1680d947p6}, + {0x1.0p0, 0x1.63ffffffffa5p6, 0x1.6405c0ac30a35p6}, + {0x1.0p0, 0x1.63ffffffffa7p6, 0x1.6405c0ac30a56p6}, + {0x1.0p0, 0x1.67ffffffff988p6, 0x1.6805b04f83ac3p6}, + {0x1.0p0, 0x1.68p6, 0x1.6805b04f8413bp6}, + {0x1.0p0, 0x1.6bfffffffffep6, 0x1.6c05a04ee40c3p6}, + {0x1.0p0, 0x1.6cp6, 0x1.6c05a04ee40e3p6}, + {0x1.0p0, 0x1.6fffffffff018p6, 0x1.700590a74f9b5p6}, + {0x1.0p0, 0x1.6fffffffffbe2p6, 0x1.700590a75057fp6}, + {0x1.0p0, 0x1.73ffffffff4ap6, 0x1.74058155e9b72p6}, + {0x1.0p0, 0x1.74p6, 0x1.74058155ea6d2p6}, + {0x1.0p0, 0x1.77ffffffffffp6, 0x1.78057257f1868p6}, + {0x1.0p0, 0x1.78p6, 0x1.78057257f1878p6}, + {0x1.0p0, 0x1.7bfffffffffep6, 0x1.7c0563aac389bp6}, + {0x1.0p0, 0x1.7bfffffffffe4p6, 0x1.7c0563aac389fp6}, + {0x1.0p0, 0x1.7ffffffffffffp6, 0x1.8005554bda349p6}, + {0x1.0p0, 0x1.8p6, 0x1.8005554bda34bp6}, + {0x1.0p0, 0x1.83fffffffffap6, 0x1.84054738c9dcdp6}, + {0x1.0p0, 0x1.84p6, 0x1.84054738c9e2dp6}, + {0x1.0p0, 0x1.87ffffffff09p6, 0x1.8805396f3f494p6}, + {0x1.0p0, 0x1.87ffffffff0bp6, 0x1.8805396f3f4b5p6}, + {0x1.0p0, 0x1.8bfffffffffep6, 0x1.8c052bed02f7ap6}, + {0x1.0p0, 0x1.8cp6, 0x1.8c052bed02f9bp6}, + {0x1.0p0, 0x1.8fffffffff7c8p6, 0x1.90051eafee07bp6}, + {0x1.0p0, 0x1.9p6, 0x1.90051eafee8b3p6}, + {0x1.0p1, 0x1.fffffffffdcb5p-1, 0x1.1e3779b97f0b5p1}, + {0x1.0p1, 0x1.ffffffffffab5p0, 0x1.6a09e667f39edp1}, + {0x1.0p1, 0x1.7ffffffffffffp1, 0x1.cd82b446159f2p1}, + {0x1.0p1, 0x1.8p1, 0x1.cd82b446159f3p1}, + {0x1.0p1, 0x1.ffffffffffffbp1, 0x1.1e3779b97f4a6p2}, + {0x1.0p1, 0x1.3fffffffffffdp2, 0x1.58a68a4a8d9fp2}, + {0x1.0p1, 0x1.3fffffffffffep2, 0x1.58a68a4a8d9f1p2}, + {0x1.0p1, 0x1.7ffffffffffffp2, 0x1.94c583ada5b51p2}, + {0x1.0p1, 0x1.bfffffffffffep2, 0x1.d1ed52076fbe7p2}, + {0x1.0p1, 0x1.cp2, 0x1.d1ed52076fbe9p2}, + {0x1.0p1, 0x1.ffffffffffffdp2, 0x1.07e0f66afed06p3}, + {0x1.0p1, 0x1.1fffffffffff2p3, 0x1.2706821902e8cp3}, + {0x1.0p1, 0x1.2p3, 0x1.2706821902e9ap3}, + {0x1.0p1, 0x1.3fffffffffffdp3, 0x1.465655f122ff3p3}, + {0x1.0p1, 0x1.4p3, 0x1.465655f122ff6p3}, + {0x1.0p1, 0x1.5ffffffffffd6p3, 0x1.65c55827df1a8p3}, + {0x1.0p1, 0x1.7ffffffffffffp3, 0x1.854bfb363dc38p3}, + {0x1.0p1, 0x1.8p3, 0x1.854bfb363dc39p3}, + {0x1.0p1, 0x1.9ffffffffffe4p3, 0x1.a4e4efeda34c2p3}, + {0x1.0p1, 0x1.ap3, 0x1.a4e4efeda34dep3}, + {0x1.0p1, 0x1.bfffffffffffep3, 0x1.c48c6001f0abdp3}, + {0x1.0p1, 0x1.dfffffffffffcp3, 0x1.e43f746f77956p3}, + {0x1.0p1, 0x1.ep3, 0x1.e43f746f7795bp3}, + {0x1.0p1, 0x1.fffffffffffffp3, 0x1.01fe03f61badp4}, + {0x1.0p1, 0x1.0ffffffffffc4p4, 0x1.11e039f40ee2ap4}, + {0x1.0p1, 0x1.0ffffffffffc7p4, 0x1.11e039f40ee2dp4}, + {0x1.0p1, 0x1.1fffffffffffap4, 0x1.21c5b70d9f81dp4}, + {0x1.0p1, 0x1.2fffffffffffcp4, 0x1.31adf859f9e5ap4}, + {0x1.0p1, 0x1.2fffffffffffep4, 0x1.31adf859f9e5cp4}, + {0x1.0p1, 0x1.3ffffffffffe5p4, 0x1.419894c2329d5p4}, + {0x1.0p1, 0x1.3ffffffffffe7p4, 0x1.419894c2329d8p4}, + {0x1.0p1, 0x1.4fffffffffff4p4, 0x1.518536f3ca668p4}, + {0x1.0p1, 0x1.5p4, 0x1.518536f3ca675p4}, + {0x1.0p1, 0x1.5ffffffffff7ep4, 0x1.617398f2aa9c6p4}, + {0x1.0p1, 0x1.5ffffffffff8dp4, 0x1.617398f2aa9d5p4}, + {0x1.0p1, 0x1.6ffffffffffb8p4, 0x1.716380ce70352p4}, + {0x1.0p1, 0x1.7p4, 0x1.716380ce7039ap4}, + {0x1.0p1, 0x1.7ffffffffff9bp4, 0x1.8154be27734c1p4}, + {0x1.0p1, 0x1.8p4, 0x1.8154be2773526p4}, + {0x1.0p1, 0x1.8ffffffffffe8p4, 0x1.9147284a4142fp4}, + {0x1.0p1, 0x1.8ffffffffffffp4, 0x1.9147284a41446p4}, + {0x1.0p1, 0x1.9fffffffffff4p4, 0x1.a13a9cb996644p4}, + {0x1.0p1, 0x1.9ffffffffffffp4, 0x1.a13a9cb99664fp4}, + {0x1.0p1, 0x1.affffffffff58p4, 0x1.b12efe0a8f113p4}, + {0x1.0p1, 0x1.affffffffffd2p4, 0x1.b12efe0a8f18dp4}, + {0x1.0p1, 0x1.bfffffffffffep4, 0x1.c12432fec0327p4}, + {0x1.0p1, 0x1.cp4, 0x1.c12432fec0329p4}, + {0x1.0p1, 0x1.cffffffffffe8p4, 0x1.d11a25cd6ed78p4}, + {0x1.0p1, 0x1.dp4, 0x1.d11a25cd6ed91p4}, + {0x1.0p1, 0x1.dffffffffffbcp4, 0x1.e110c39105f6bp4}, + {0x1.0p1, 0x1.ep4, 0x1.e110c39105fafp4}, + {0x1.0p1, 0x1.effffffffffe8p4, 0x1.f107fbd0adcf1p4}, + {0x1.0p1, 0x1.efffffffffff8p4, 0x1.f107fbd0addp4}, + {0x1.0p1, 0x1.ffffffffffeafp4, 0x1.007fe00ff5fc8p5}, + {0x1.0p1, 0x1.07fffffffffe8p5, 0x1.087c01e7d5092p5}, + {0x1.0p1, 0x1.08p5, 0x1.087c01e7d50abp5}, + {0x1.0p1, 0x1.0fffffffffff4p5, 0x1.10785dd689a1cp5}, + {0x1.0p1, 0x1.0fffffffffffbp5, 0x1.10785dd689a23p5}, + {0x1.0p1, 0x1.17ffffffffed8p5, 0x1.1874eee5c5cb1p5}, + {0x1.0p1, 0x1.17ffffffffee8p5, 0x1.1874eee5c5cc2p5}, + {0x1.0p1, 0x1.1ffffffffff92p5, 0x1.2071b0abcd7cap5}, + {0x1.0p1, 0x1.1ffffffffff99p5, 0x1.2071b0abcd7d1p5}, + {0x1.0p1, 0x1.27ffffffffea8p5, 0x1.286e9f388de9fp5}, + {0x1.0p1, 0x1.28p5, 0x1.286e9f388dff7p5}, + {0x1.0p1, 0x1.2fffffffffffcp5, 0x1.306bb705ae7bfp5}, + {0x1.0p1, 0x1.2ffffffffffffp5, 0x1.306bb705ae7c3p5}, + {0x1.0p1, 0x1.37ffffffffff8p5, 0x1.3868f4e9108b9p5}, + {0x1.0p1, 0x1.38p5, 0x1.3868f4e9108c1p5}, + {0x1.0p1, 0x1.3fffffffffffdp5, 0x1.4066560954a8bp5}, + {0x1.0p1, 0x1.47ffffffffe28p5, 0x1.4863d7d40ad39p5}, + {0x1.0p1, 0x1.48p5, 0x1.4863d7d40af11p5}, + {0x1.0p1, 0x1.4fffffffffe14p5, 0x1.506177f548fcfp5}, + {0x1.0p1, 0x1.5p5, 0x1.506177f5491bbp5}, + {0x1.0p1, 0x1.57ffffffffeb8p5, 0x1.585f34506bafbp5}, + {0x1.0p1, 0x1.58p5, 0x1.585f34506bc43p5}, + {0x1.0p1, 0x1.5fffffffffffdp5, 0x1.605d0af9d3a42p5}, + {0x1.0p1, 0x1.5fffffffffffep5, 0x1.605d0af9d3a42p5}, + {0x1.0p1, 0x1.67ffffffffda8p5, 0x1.685afa317791bp5}, + {0x1.0p1, 0x1.68p5, 0x1.685afa3177b73p5}, + {0x1.0p1, 0x1.6fffffffffff8p5, 0x1.7059005e2c015p5}, + {0x1.0p1, 0x1.6ffffffffffffp5, 0x1.7059005e2c01dp5}, + {0x1.0p1, 0x1.77ffffffffffp5, 0x1.78571c0982328p5}, + {0x1.0p1, 0x1.78p5, 0x1.78571c0982339p5}, + {0x1.0p1, 0x1.7fffffffffffdp5, 0x1.80554bdc2dc4dp5}, + {0x1.0p1, 0x1.7ffffffffffffp5, 0x1.80554bdc2dc4ep5}, + {0x1.0p1, 0x1.87fffffffffdp5, 0x1.88538e9ad8dacp5}, + {0x1.0p1, 0x1.87fffffffffffp5, 0x1.88538e9ad8ddbp5}, + {0x1.0p1, 0x1.8fffffffffe68p5, 0x1.9051e3235a2cp5}, + {0x1.0p1, 0x1.9p5, 0x1.9051e3235a458p5}, + {0x1.0p1, 0x1.97ffffffffffp5, 0x1.9850486a3f17p5}, + {0x1.0p1, 0x1.97fffffffffffp5, 0x1.9850486a3f17fp5}, + {0x1.0p1, 0x1.9fffffffffff4p5, 0x1.a04ebd789d00cp5}, + {0x1.0p1, 0x1.ap5, 0x1.a04ebd789d019p5}, + {0x1.0p1, 0x1.a7ffffffffe1p5, 0x1.a84d416a2354dp5}, + {0x1.0p1, 0x1.a8p5, 0x1.a84d416a2373dp5}, + {0x1.0p1, 0x1.afffffffffed8p5, 0x1.b04bd36b639fbp5}, + {0x1.0p1, 0x1.affffffffff43p5, 0x1.b04bd36b63a66p5}, + {0x1.0p1, 0x1.b7ffffffffd7p5, 0x1.b84a72b848951p5}, + {0x1.0p1, 0x1.b7ffffffffe2bp5, 0x1.b84a72b848a0cp5}, + {0x1.0p1, 0x1.bfffffffffe3ep5, 0x1.c0491e9ab90fdp5}, + {0x1.0p1, 0x1.cp5, 0x1.c0491e9ab92bfp5}, + {0x1.0p1, 0x1.c7fffffffffdp5, 0x1.c847d6695dbc5p5}, + {0x1.0p1, 0x1.c8p5, 0x1.c847d6695dbf6p5}, + {0x1.0p1, 0x1.cfffffffffed8p5, 0x1.d0469986884d6p5}, + {0x1.0p1, 0x1.cfffffffffee8p5, 0x1.d0469986884e5p5}, + {0x1.0p1, 0x1.d7ffffffffdfp5, 0x1.d845675f37721p5}, + {0x1.0p1, 0x1.d8p5, 0x1.d845675f37931p5}, + {0x1.0p1, 0x1.dfffffffffe5cp5, 0x1.e0443f6a33104p5}, + {0x1.0p1, 0x1.dffffffffffffp5, 0x1.e0443f6a332a7p5}, + {0x1.0p1, 0x1.e7fffffffff05p5, 0x1.e84321273f31ep5}, + {0x1.0p1, 0x1.e7fffffffff1p5, 0x1.e84321273f328p5}, + {0x1.0p1, 0x1.efffffffffff8p5, 0x1.f0420c1e63084p5}, + {0x1.0p1, 0x1.fp5, 0x1.f0420c1e6308dp5}, + {0x1.0p1, 0x1.f7ffffffffc3p5, 0x1.f840ffdf40effp5}, + {0x1.0p1, 0x1.f7fffffffff08p5, 0x1.f840ffdf411d7p5}, + {0x1.0p1, 0x1.ffffffffffffdp5, 0x1.001ffe003ff5fp6}, + {0x1.0p1, 0x1.03fffffffffdp6, 0x1.041f800f9f928p6}, + {0x1.0p1, 0x1.03ffffffffffap6, 0x1.041f800f9f953p6}, + {0x1.0p1, 0x1.07ffffffffed8p6, 0x1.081f05ef4d755p6}, + {0x1.0p1, 0x1.07ffffffffee8p6, 0x1.081f05ef4d764p6}, + {0x1.0p1, 0x1.0bfffffffff5p6, 0x1.0c1e8f739cdcap6}, + {0x1.0p1, 0x1.0bfffffffff7p6, 0x1.0c1e8f739cde9p6}, + {0x1.0p1, 0x1.0fffffffffff4p6, 0x1.101e1c7371c6bp6}, + {0x1.0p1, 0x1.0fffffffffffbp6, 0x1.101e1c7371c72p6}, + {0x1.0p1, 0x1.13fffffffffdp6, 0x1.141dacc811a34p6}, + {0x1.0p1, 0x1.13ffffffffffcp6, 0x1.141dacc811a6p6}, + {0x1.0p1, 0x1.17ffffffffff8p6, 0x1.181d404cf7f51p6}, + {0x1.0p1, 0x1.17ffffffffffdp6, 0x1.181d404cf7f56p6}, + {0x1.0p1, 0x1.1bffffffffffp6, 0x1.1c1cd6dfae4a5p6}, + {0x1.0p1, 0x1.1bffffffffffep6, 0x1.1c1cd6dfae4b4p6}, + {0x1.0p1, 0x1.1fffffffffbf2p6, 0x1.201c705fa7a27p6}, + {0x1.0p1, 0x1.1fffffffffc65p6, 0x1.201c705fa7a9ap6}, + {0x1.0p1, 0x1.23fffffffffdp6, 0x1.241c0cae201cap6}, + {0x1.0p1, 0x1.23ffffffffffp6, 0x1.241c0cae201ebp6}, + {0x1.0p1, 0x1.27ffffffffe08p6, 0x1.281babadfba01p6}, + {0x1.0p1, 0x1.28p6, 0x1.281babadfbbf9p6}, + {0x1.0p1, 0x1.2bffffffffc1p6, 0x1.2c1b4d43ac4cfp6}, + {0x1.0p1, 0x1.2bffffffffc3p6, 0x1.2c1b4d43ac4eep6}, + {0x1.0p1, 0x1.2ffffffffff64p6, 0x1.301af15517357p6}, + {0x1.0p1, 0x1.2ffffffffff6cp6, 0x1.301af1551735ep6}, + {0x1.0p1, 0x1.33ffffffffadp6, 0x1.341a97c97b22ep6}, + {0x1.0p1, 0x1.33ffffffffafp6, 0x1.341a97c97b24fp6}, + {0x1.0p1, 0x1.37ffffffffc78p6, 0x1.381a40895d3f5p6}, + {0x1.0p1, 0x1.37ffffffffc88p6, 0x1.381a40895d406p6}, + {0x1.0p1, 0x1.3bffffffffffp6, 0x1.3c19eb7e71afcp6}, + {0x1.0p1, 0x1.3bfffffffffffp6, 0x1.3c19eb7e71b0cp6}, + {0x1.0p1, 0x1.3fffffffffffdp6, 0x1.4019989389b2dp6}, + {0x1.0p1, 0x1.4p6, 0x1.4019989389b3p6}, + {0x1.0p1, 0x1.43fffffffffdp6, 0x1.441947b4829e8p6}, + {0x1.0p1, 0x1.43ffffffffff8p6, 0x1.441947b482a11p6}, + {0x1.0p1, 0x1.47fffffffffe8p6, 0x1.4818f8ce34e19p6}, + {0x1.0p1, 0x1.47ffffffffffap6, 0x1.4818f8ce34e2cp6}, + {0x1.0p1, 0x1.4bffffffffffp6, 0x1.4c18abce6501fp6}, + {0x1.0p1, 0x1.4bffffffffffcp6, 0x1.4c18abce6502cp6}, + {0x1.0p1, 0x1.4fffffffffa64p6, 0x1.501860a3b54bep6}, + {0x1.0p1, 0x1.4fffffffffe47p6, 0x1.501860a3b58a1p6}, + {0x1.0p1, 0x1.53ffffffffd5p6, 0x1.5418173d9a501p6}, + {0x1.0p1, 0x1.53ffffffffd7p6, 0x1.5418173d9a522p6}, + {0x1.0p1, 0x1.57ffffffffff8p6, 0x1.5817cf8c4c199p6}, + {0x1.0p1, 0x1.57fffffffffffp6, 0x1.5817cf8c4c1ap6}, + {0x1.0p1, 0x1.5bffffffff83p6, 0x1.5c178980bc34bp6}, + {0x1.0p1, 0x1.5bffffffff988p6, 0x1.5c178980bc4a3p6}, + {0x1.0p1, 0x1.5fffffffffbeep6, 0x1.6017450c8d3e7p6}, + {0x1.0p1, 0x1.6p6, 0x1.6017450c8d7f9p6}, + {0x1.0p1, 0x1.63fffffffffdp6, 0x1.6417022204f99p6}, + {0x1.0p1, 0x1.67fffffffffe8p6, 0x1.6816c0b405afp6}, + {0x1.0p1, 0x1.68p6, 0x1.6816c0b405b09p6}, + {0x1.0p1, 0x1.6bfffffffffep6, 0x1.6c1680b6059e8p6}, + {0x1.0p1, 0x1.6cp6, 0x1.6c1680b605a08p6}, + {0x1.0p1, 0x1.6fffffffffb78p6, 0x1.7016421c06043p6}, + {0x1.0p1, 0x1.7p6, 0x1.7016421c064cbp6}, + {0x1.0p1, 0x1.73fffffffffap6, 0x1.741604da8d2b9p6}, + {0x1.0p1, 0x1.73ffffffffff8p6, 0x1.741604da8d311p6}, + {0x1.0p1, 0x1.77ffffffffffp6, 0x1.7815c8e69cc37p6}, + {0x1.0p1, 0x1.77ffffffffffcp6, 0x1.7815c8e69cc43p6}, + {0x1.0p1, 0x1.7bfffffffffep6, 0x1.7c158e35adde4p6}, + {0x1.0p1, 0x1.7bfffffffffe8p6, 0x1.7c158e35addecp6}, + {0x1.0p1, 0x1.7ffffffffffffp6, 0x1.801554bda99c5p6}, + {0x1.0p1, 0x1.83ffffffffdap6, 0x1.84151c74e35e4p6}, + {0x1.0p1, 0x1.83ffffffffdep6, 0x1.84151c74e3625p6}, + {0x1.0p1, 0x1.87fffffffffdp6, 0x1.8814e55214271p6}, + {0x1.0p1, 0x1.87ffffffffffcp6, 0x1.8814e5521429ep6}, + {0x1.0p1, 0x1.8bfffffffffep6, 0x1.8c14af4c540b6p6}, + {0x1.0p1, 0x1.8bffffffffff6p6, 0x1.8c14af4c540cdp6}, + {0x1.0p1, 0x1.8ffffffffffe8p6, 0x1.90147a5b16ce5p6}, + {0x1.0p1, 0x1.8fffffffffffcp6, 0x1.90147a5b16cfap6}, + {0x1.8p1, 0x1.ffffffffffffdp-1, 0x1.94c583ada5b53p1}, + {0x1.8p1, 0x1.0p1, 0x1.cd82b446159f3p1}, + {0x1.8p1, 0x1.7fffffffffff7p1, 0x1.0f876ccdf6cd6p2}, + {0x1.8p1, 0x1.8p1, 0x1.0f876ccdf6cd9p2}, + {0x1.8p1, 0x1.fffffffffffffp1, 0x1.4p2}, + {0x1.8p1, 0x1.3ffffffffffe1p2, 0x1.752e50db3a387p2}, + {0x1.8p1, 0x1.4p2, 0x1.752e50db3a3a2p2}, + {0x1.8p1, 0x1.7ffffffffffffp2, 0x1.ad5336963eefap2}, + {0x1.8p1, 0x1.bfffffffffffep2, 0x1.e768d399dc46dp2}, + {0x1.8p1, 0x1.bffffffffffffp2, 0x1.e768d399dc46fp2}, + {0x1.8p1, 0x1.fffffffffffffp2, 0x1.11687a8ae14a3p3}, + {0x1.8p1, 0x1.1fffffffffff2p3, 0x1.2f9422c23c47p3}, + {0x1.8p1, 0x1.1fffffffffff7p3, 0x1.2f9422c23c475p3}, + {0x1.8p1, 0x1.3fffffffffff1p3, 0x1.4e16fdacff928p3}, + {0x1.8p1, 0x1.3fffffffffff4p3, 0x1.4e16fdacff92bp3}, + {0x1.8p1, 0x1.5ffffffffffffp3, 0x1.6cdb2bbb212ebp3}, + {0x1.8p1, 0x1.7fffffffffffdp3, 0x1.8bd171a07e388p3}, + {0x1.8p1, 0x1.7ffffffffffffp3, 0x1.8bd171a07e389p3}, + {0x1.8p1, 0x1.9ffffffffffe4p3, 0x1.aaeee979b481cp3}, + {0x1.8p1, 0x1.9ffffffffffecp3, 0x1.aaeee979b4825p3}, + {0x1.8p1, 0x1.bffffffffffeep3, 0x1.ca2b9714180e5p3}, + {0x1.8p1, 0x1.cp3, 0x1.ca2b9714180f7p3}, + {0x1.8p1, 0x1.dfffffffffffcp3, 0x1.e98180e9b47edp3}, + {0x1.8p1, 0x1.dfffffffffffep3, 0x1.e98180e9b47efp3}, + {0x1.8p1, 0x1.fffffffffffffp3, 0x1.04760c95db31p4}, + {0x1.8p1, 0x1.0fffffffffff4p4, 0x1.1433ec467efefp4}, + {0x1.8p1, 0x1.1ffffffffffeap4, 0x1.23f8fc68ae515p4}, + {0x1.8p1, 0x1.2p4, 0x1.23f8fc68ae52bp4}, + {0x1.8p1, 0x1.2fffffffffffcp4, 0x1.33c42213ee0c5p4}, + {0x1.8p1, 0x1.3p4, 0x1.33c42213ee0c9p4}, + {0x1.8p1, 0x1.3ffffffffffd9p4, 0x1.439479381ec96p4}, + {0x1.8p1, 0x1.3fffffffffff6p4, 0x1.439479381ecb3p4}, + {0x1.8p1, 0x1.4ffffffffffc4p4, 0x1.53694801747d4p4}, + {0x1.8p1, 0x1.4ffffffffffccp4, 0x1.53694801747dcp4}, + {0x1.8p1, 0x1.5ffffffffffbep4, 0x1.6341f58bad9d2p4}, + {0x1.8p1, 0x1.5ffffffffffc2p4, 0x1.6341f58bad9d7p4}, + {0x1.8p1, 0x1.6fffffffffff8p4, 0x1.731e02ed21f18p4}, + {0x1.8p1, 0x1.6ffffffffffffp4, 0x1.731e02ed21f2p4}, + {0x1.8p1, 0x1.7fffffffffffdp4, 0x1.82fd05f129836p4}, + {0x1.8p1, 0x1.7ffffffffffffp4, 0x1.82fd05f129837p4}, + {0x1.8p1, 0x1.8ffffffffffa8p4, 0x1.92dea50d28578p4}, + {0x1.8p1, 0x1.8ffffffffffffp4, 0x1.92dea50d285cep4}, + {0x1.8p1, 0x1.9ffffffffffe4p4, 0x1.a2c2943e2866p4}, + {0x1.8p1, 0x1.9fffffffffffcp4, 0x1.a2c2943e28678p4}, + {0x1.8p1, 0x1.afffffffffff8p4, 0x1.b2a892946f42dp4}, + {0x1.8p1, 0x1.afffffffffffep4, 0x1.b2a892946f434p4}, + {0x1.8p1, 0x1.bffffffffffeep4, 0x1.c2906842b6bf3p4}, + {0x1.8p1, 0x1.bfffffffffff2p4, 0x1.c2906842b6bf8p4}, + {0x1.8p1, 0x1.cffffffffffe8p4, 0x1.d279e51208c72p4}, + {0x1.8p1, 0x1.dp4, 0x1.d279e51208c8ap4}, + {0x1.8p1, 0x1.dfffffffffff4p4, 0x1.e264df234beddp4}, + {0x1.8p1, 0x1.dfffffffffffcp4, 0x1.e264df234bee4p4}, + {0x1.8p1, 0x1.efffffffffff8p4, 0x1.f25131ed54d64p4}, + {0x1.8p1, 0x1.fp4, 0x1.f25131ed54d6cp4}, + {0x1.8p1, 0x1.fffffffffffffp4, 0x1.011f5eb54147p5}, + {0x1.8p1, 0x1.07fffffffff88p5, 0x1.0916b2b5fff3ep5}, + {0x1.8p1, 0x1.07fffffffffaap5, 0x1.0916b2b5fff6p5}, + {0x1.8p1, 0x1.0ffffffffffc4p5, 0x1.110e8885865b8p5}, + {0x1.8p1, 0x1.0ffffffffffccp5, 0x1.110e8885865c1p5}, + {0x1.8p1, 0x1.17fffffffff58p5, 0x1.1906d51932b7ep5}, + {0x1.8p1, 0x1.17fffffffff77p5, 0x1.1906d51932b9dp5}, + {0x1.8p1, 0x1.1fffffffffffap5, 0x1.20ff8e9d967d6p5}, + {0x1.8p1, 0x1.1fffffffffffep5, 0x1.20ff8e9d967dbp5}, + {0x1.8p1, 0x1.27fffffffffc8p5, 0x1.28f8ac4cd98f2p5}, + {0x1.8p1, 0x1.27fffffffffd8p5, 0x1.28f8ac4cd9903p5}, + {0x1.8p1, 0x1.2ffffffffff7cp5, 0x1.30f2264b9c502p5}, + {0x1.8p1, 0x1.2ffffffffffafp5, 0x1.30f2264b9c535p5}, + {0x1.8p1, 0x1.37ffffffffff8p5, 0x1.38ebf58b30cb4p5}, + {0x1.8p1, 0x1.37fffffffffffp5, 0x1.38ebf58b30cbcp5}, + {0x1.8p1, 0x1.3fffffffffffdp5, 0x1.40e613b03f1dcp5}, + {0x1.8p1, 0x1.3ffffffffffffp5, 0x1.40e613b03f1dfp5}, + {0x1.8p1, 0x1.47fffffffffa1p5, 0x1.48e07afd169d5p5}, + {0x1.8p1, 0x1.47fffffffffa8p5, 0x1.48e07afd169dbp5}, + {0x1.8p1, 0x1.4ffffffffff84p5, 0x1.50db263f101e3p5}, + {0x1.8p1, 0x1.4ffffffffff8cp5, 0x1.50db263f101ecp5}, + {0x1.8p1, 0x1.57ffffffffff8p5, 0x1.58d610be831eep5}, + {0x1.8p1, 0x1.58p5, 0x1.58d610be831f7p5}, + {0x1.8p1, 0x1.5fffffffffffap5, 0x1.60d13630e611p5}, + {0x1.8p1, 0x1.5fffffffffffep5, 0x1.60d13630e6113p5}, + {0x1.8p1, 0x1.67fffffffffe8p5, 0x1.68cc92acc47abp5}, + {0x1.8p1, 0x1.68p5, 0x1.68cc92acc47c3p5}, + {0x1.8p1, 0x1.6fffffffffff8p5, 0x1.70c8229f43a38p5}, + {0x1.8p1, 0x1.6fffffffffffap5, 0x1.70c8229f43a3ap5}, + {0x1.8p1, 0x1.77ffffffffffp5, 0x1.78c3e2c2fb433p5}, + {0x1.8p1, 0x1.77ffffffffffep5, 0x1.78c3e2c2fb441p5}, + {0x1.8p1, 0x1.7ffffffffffffp5, 0x1.80bfd017f10a6p5}, + {0x1.8p1, 0x1.87fffffffff5p5, 0x1.88bbe7dc8d9ap5}, + {0x1.8p1, 0x1.88p5, 0x1.88bbe7dc8da5p5}, + {0x1.8p1, 0x1.8ffffffffffe8p5, 0x1.90b8278768b67p5}, + {0x1.8p1, 0x1.9p5, 0x1.90b8278768b8p5}, + {0x1.8p1, 0x1.97fffffffff2bp5, 0x1.98b48cc1ce669p5}, + {0x1.8p1, 0x1.97fffffffff3p5, 0x1.98b48cc1ce66dp5}, + {0x1.8p1, 0x1.9ffffffffff34p5, 0x1.a0b11562e5efcp5}, + {0x1.8p1, 0x1.ap5, 0x1.a0b11562e5fc8p5}, + {0x1.8p1, 0x1.a7fffffffffdp5, 0x1.a8adbf6b63874p5}, + {0x1.8p1, 0x1.a8p5, 0x1.a8adbf6b638a4p5}, + {0x1.8p1, 0x1.affffffffffd8p5, 0x1.b0aa8901b442cp5}, + {0x1.8p1, 0x1.affffffffffe8p5, 0x1.b0aa8901b443dp5}, + {0x1.8p1, 0x1.b7ffffffffffp5, 0x1.b8a7706e94761p5}, + {0x1.8p1, 0x1.b7ffffffffffep5, 0x1.b8a7706e9477p5}, + {0x1.8p1, 0x1.bfffffffffffep5, 0x1.c0a4741a02dcap5}, + {0x1.8p1, 0x1.cp5, 0x1.c0a4741a02dcdp5}, + {0x1.8p1, 0x1.c7fffffffffdp5, 0x1.c8a1928885b75p5}, + {0x1.8p1, 0x1.c7ffffffffff9p5, 0x1.c8a1928885b9fp5}, + {0x1.8p1, 0x1.cffffffffff28p5, 0x1.d09eca58b7d2cp5}, + {0x1.8p1, 0x1.dp5, 0x1.d09eca58b7e04p5}, + {0x1.8p1, 0x1.d7ffffffffffp5, 0x1.d89c1a4115253p5}, + {0x1.8p1, 0x1.d8p5, 0x1.d89c1a4115264p5}, + {0x1.8p1, 0x1.dfffffffffffcp5, 0x1.e099810dfefd1p5}, + {0x1.8p1, 0x1.e7fffffffffdp5, 0x1.e896fd9ff2afep5}, + {0x1.8p1, 0x1.e7ffffffffffap5, 0x1.e896fd9ff2b29p5}, + {0x1.8p1, 0x1.effffffffff98p5, 0x1.f0948ee9ebc7bp5}, + {0x1.8p1, 0x1.effffffffffcap5, 0x1.f0948ee9ebcadp5}, + {0x1.8p1, 0x1.f7fffffffff7p5, 0x1.f89233efeda08p5}, + {0x1.8p1, 0x1.f7fffffffffb2p5, 0x1.f89233efeda4ap5}, + {0x1.8p1, 0x1.ffffffffffda9p5, 0x1.0047f5e2d7ed7p6}, + {0x1.8p1, 0x1.03ffffffffedp6, 0x1.0446dac6b5468p6}, + {0x1.8p1, 0x1.04p6, 0x1.0446dac6b5598p6}, + {0x1.8p1, 0x1.07fffffffffe8p6, 0x1.0845c83b5eb9bp6}, + {0x1.8p1, 0x1.07ffffffffff9p6, 0x1.0845c83b5ebadp6}, + {0x1.8p1, 0x1.0bffffffffe9bp6, 0x1.0c44bdded82bdp6}, + {0x1.8p1, 0x1.0bffffffffebp6, 0x1.0c44bdded82d1p6}, + {0x1.8p1, 0x1.0fffffffffed4p6, 0x1.1043bb54e5cc9p6}, + {0x1.8p1, 0x1.0ffffffffff1fp6, 0x1.1043bb54e5d14p6}, + {0x1.8p1, 0x1.13ffffffffe9p6, 0x1.1442c046a0ea6p6}, + {0x1.8p1, 0x1.13fffffffff5ap6, 0x1.1442c046a0f7p6}, + {0x1.8p1, 0x1.17fffffffffa8p6, 0x1.1841cc62174cbp6}, + {0x1.8p1, 0x1.17fffffffffb8p6, 0x1.1841cc62174dap6}, + {0x1.8p1, 0x1.1bffffffffffp6, 0x1.1c40df59f1a57p6}, + {0x1.8p1, 0x1.1cp6, 0x1.1c40df59f1a67p6}, + {0x1.8p1, 0x1.1fffffffffffap6, 0x1.203ff8e522535p6}, + {0x1.8p1, 0x1.1ffffffffffffp6, 0x1.203ff8e52253bp6}, + {0x1.8p1, 0x1.23fffffffffdp6, 0x1.243f18be9a334p6}, + {0x1.8p1, 0x1.23ffffffffffbp6, 0x1.243f18be9a36p6}, + {0x1.8p1, 0x1.27fffffffffe8p6, 0x1.283e3ea503c63p6}, + {0x1.8p1, 0x1.27ffffffffff8p6, 0x1.283e3ea503c74p6}, + {0x1.8p1, 0x1.2bffffffffdfp6, 0x1.2c3d6a5a83932p6}, + {0x1.8p1, 0x1.2bffffffffe1p6, 0x1.2c3d6a5a83953p6}, + {0x1.8p1, 0x1.2fffffffffffcp6, 0x1.303c9ba47e6d4p6}, + {0x1.8p1, 0x1.3p6, 0x1.303c9ba47e6d8p6}, + {0x1.8p1, 0x1.33fffffffffdp6, 0x1.343bd24b62468p6}, + {0x1.8p1, 0x1.33fffffffffffp6, 0x1.343bd24b62498p6}, + {0x1.8p1, 0x1.37ffffffffff8p6, 0x1.383b0e1a75c0ap6}, + {0x1.8p1, 0x1.37fffffffffffp6, 0x1.383b0e1a75c12p6}, + {0x1.8p1, 0x1.3bffffffffffp6, 0x1.3c3a4edfa9748p6}, + {0x1.8p1, 0x1.3bffffffffffep6, 0x1.3c3a4edfa9756p6}, + {0x1.8p1, 0x1.3fffffffffd4dp6, 0x1.4039946b6d79fp6}, + {0x1.8p1, 0x1.3ffffffffffffp6, 0x1.4039946b6da51p6}, + {0x1.8p1, 0x1.43fffffffff9p6, 0x1.4438de908abeap6}, + {0x1.8p1, 0x1.43fffffffffbp6, 0x1.4438de908ac0bp6}, + {0x1.8p1, 0x1.47ffffffffd08p6, 0x1.48382d23fccedp6}, + {0x1.8p1, 0x1.47fffffffffa2p6, 0x1.48382d23fcf87p6}, + {0x1.8p1, 0x1.4bffffffffcebp6, 0x1.4c377ffcd212fp6}, + {0x1.8p1, 0x1.4bffffffffcfp6, 0x1.4c377ffcd2133p6}, + {0x1.8p1, 0x1.4ffffffffff44p6, 0x1.5036d6f40ad53p6}, + {0x1.8p1, 0x1.4ffffffffff9bp6, 0x1.5036d6f40adaap6}, + {0x1.8p1, 0x1.53ffffffffedp6, 0x1.543631e47c1e1p6}, + {0x1.8p1, 0x1.54p6, 0x1.543631e47c311p6}, + {0x1.8p1, 0x1.57ffffffffd78p6, 0x1.583590aab542dp6}, + {0x1.8p1, 0x1.58p6, 0x1.583590aab56b5p6}, + {0x1.8p1, 0x1.5bffffffffc7p6, 0x1.5c34f324e60eep6}, + {0x1.8p1, 0x1.5bffffffffc9p6, 0x1.5c34f324e610fp6}, + {0x1.8p1, 0x1.5fffffffffffdp6, 0x1.60345932c760dp6}, + {0x1.8p1, 0x1.5fffffffffffep6, 0x1.60345932c760dp6}, + {0x1.8p1, 0x1.63fffffffff79p6, 0x1.6433c2b58421fp6}, + {0x1.8p1, 0x1.63fffffffff9p6, 0x1.6433c2b584235p6}, + {0x1.8p1, 0x1.67ffffffffda8p6, 0x1.68332f8fa63a6p6}, + {0x1.8p1, 0x1.67fffffffff4dp6, 0x1.68332f8fa654bp6}, + {0x1.8p1, 0x1.6bfffffffffep6, 0x1.6c329fa502ccfp6}, + {0x1.8p1, 0x1.6cp6, 0x1.6c329fa502cefp6}, + {0x1.8p1, 0x1.6fffffffffff8p6, 0x1.703212daa75f3p6}, + {0x1.8p1, 0x1.6ffffffffffffp6, 0x1.703212daa75fbp6}, + {0x1.8p1, 0x1.73fffffffffap6, 0x1.74318916ca409p6}, + {0x1.8p1, 0x1.74p6, 0x1.74318916ca46ap6}, + {0x1.8p1, 0x1.77ffffffffffp6, 0x1.78310240ba47p6}, + {0x1.8p1, 0x1.78p6, 0x1.78310240ba481p6}, + {0x1.8p1, 0x1.7bfffffffffep6, 0x1.7c307e40cff7fp6}, + {0x1.8p1, 0x1.7bfffffffffe4p6, 0x1.7c307e40cff83p6}, + {0x1.8p1, 0x1.7fffffffffff7p6, 0x1.802ffd005ff07p6}, + {0x1.8p1, 0x1.7fffffffffff9p6, 0x1.802ffd005ff0ap6}, + {0x1.8p1, 0x1.83fffffffffap6, 0x1.842f7e69adc1ep6}, + {0x1.8p1, 0x1.83fffffffffffp6, 0x1.842f7e69adc7dp6}, + {0x1.8p1, 0x1.87fffffffffdp6, 0x1.882f0267dfef4p6}, + {0x1.8p1, 0x1.88p6, 0x1.882f0267dff24p6}, + {0x1.8p1, 0x1.8bfffffffffep6, 0x1.8c2e88e6f449ap6}, + {0x1.8p1, 0x1.8bffffffffff6p6, 0x1.8c2e88e6f44b1p6}, + {0x1.8p1, 0x1.8ffffffffffe8p6, 0x1.902e11d3b5549p6}, + {0x1.8p1, 0x1.8fffffffffffep6, 0x1.902e11d3b556p6}, + }; + + for (double[] testCase: testCases) + failures+=testHypotCase(testCase[0], testCase[1], testCase[2]); + + return failures; + } + + public static void main(String [] argv) { + int failures = 0; + + failures += testHypot(); + + if (failures > 0) { + System.err.println("Testing log1p incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:12:59 2009 +++ new/test/java/lang/StrictMath/Log10Tests.java Mon Jan 26 16:12:58 2009 @@ -0,0 +1,724 @@ +/* + * 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 4074599 + * @summary Tests for StrictMath.log10 + * @author Joseph D. Darcy + */ + + +/** + * The tests in ../Math/Log10Tests.java test properties that should + * hold for any log10 implementation, including the FDLIBM-based one + * required for StrictMath.log10. Therefore, the test cases in + * ../Math/Log10Tests.java are run against both the Math and + * StrictMath versions of log10. The role of this test is to verify + * that the FDLIBM log10 algorithm is being used by running golden + * file tests on values that may vary from one conforming log10 + * implementation to another. + */ + +public class Log10Tests { + private Log10Tests(){} + + static int testLog10Case(double input, double expected) { + return Tests.test("StrictMath.log10(double)", input, + StrictMath.log10(input), expected); + } + + static int testLog10() { + int failures = 0; + double [][] testCases = { + {0x1.3fffffffffec1p-297, -0x1.653c6a27ae2f8p6}, + {0x1.4p-297, -0x1.653c6a27ae2f7p6}, + {0x1.3fffffffffbe1p-296, -0x1.640828f2a4382p6}, + {0x1.4p-296, -0x1.640828f2a437dp6}, + {0x1.3fffffffffd52p-295, -0x1.62d3e7bd9a406p6}, + {0x1.4p-295, -0x1.62d3e7bd9a403p6}, + {0x1.3fffffffffa72p-294, -0x1.619fa6889049p6}, + {0x1.4p-294, -0x1.619fa68890489p6}, + {0x1.3fffffffff9bbp-293, -0x1.606b655386518p6}, + {0x1.4p-293, -0x1.606b65538650fp6}, + {0x1.3fffffffffbe4p-292, -0x1.5f37241e7c59ap6}, + {0x1.4p-292, -0x1.5f37241e7c595p6}, + {0x1.3ffffffffff7ep-291, -0x1.5e02e2e97261cp6}, + {0x1.4p-291, -0x1.5e02e2e97261bp6}, + {0x1.3fffffffffc9ep-290, -0x1.5ccea1b4686a6p6}, + {0x1.4p-290, -0x1.5ccea1b4686a1p6}, + {0x1.3fffffffffec7p-289, -0x1.5b9a607f5e728p6}, + {0x1.4p-289, -0x1.5b9a607f5e727p6}, + {0x1.3fffffffffbe7p-288, -0x1.5a661f4a547b2p6}, + {0x1.4p-288, -0x1.5a661f4a547adp6}, + {0x1.3fffffffff907p-287, -0x1.5931de154a83cp6}, + {0x1.4p-287, -0x1.5931de154a833p6}, + {0x1.3fffffffffd59p-286, -0x1.57fd9ce0408bcp6}, + {0x1.4p-286, -0x1.57fd9ce0408b9p6}, + {0x1.3fffffffffecap-285, -0x1.56c95bab3694p6}, + {0x1.4p-285, -0x1.56c95bab3693fp6}, + {0x1.3fffffffffbeap-284, -0x1.55951a762c9cap6}, + {0x1.4p-284, -0x1.55951a762c9c5p6}, + {0x1.3ffffffffff84p-283, -0x1.5460d94122a4cp6}, + {0x1.4p-283, -0x1.5460d94122a4bp6}, + {0x1.3fffffffffca4p-282, -0x1.532c980c18ad6p6}, + {0x1.4p-282, -0x1.532c980c18ad1p6}, + {0x1.3fffffffff9c4p-281, -0x1.51f856d70eb6p6}, + {0x1.4p-281, -0x1.51f856d70eb57p6}, + {0x1.3fffffffffe16p-280, -0x1.50c415a204bep6}, + {0x1.4p-280, -0x1.50c415a204bddp6}, + {0x1.3fffffffffd5ep-279, -0x1.4f8fd46cfac66p6}, + {0x1.4p-279, -0x1.4f8fd46cfac63p6}, + {0x1.3fffffffffd5fp-278, -0x1.4e5b9337f0cecp6}, + {0x1.4p-278, -0x1.4e5b9337f0ce9p6}, + {0x1.3fffffffffedp-277, -0x1.4d275202e6d7p6}, + {0x1.4p-277, -0x1.4d275202e6d6fp6}, + {0x1.3fffffffffbfp-276, -0x1.4bf310cddcdfap6}, + {0x1.4p-276, -0x1.4bf310cddcdf5p6}, + {0x1.3ffffffffff8ap-275, -0x1.4abecf98d2e7bp6}, + {0x1.4p-275, -0x1.4abecf98d2e7bp6}, + {0x1.3fffffffffd62p-274, -0x1.498a8e63c8f04p6}, + {0x1.4p-274, -0x1.498a8e63c8f01p6}, + {0x1.3fffffffff9cap-273, -0x1.48564d2ebef9p6}, + {0x1.4p-273, -0x1.48564d2ebef87p6}, + {0x1.3fffffffff6eap-272, -0x1.47220bf9b501ap6}, + {0x1.4p-272, -0x1.47220bf9b500dp6}, + {0x1.3fffffffffb3cp-271, -0x1.45edcac4ab09ap6}, + {0x1.4p-271, -0x1.45edcac4ab093p6}, + {0x1.3fffffffffd65p-270, -0x1.44b9898fa111cp6}, + {0x1.4p-270, -0x1.44b9898fa1119p6}, + {0x1.3fffffffffa85p-269, -0x1.4385485a971a6p6}, + {0x1.4p-269, -0x1.4385485a9719fp6}, + {0x1.3ffffffffe2c7p-268, -0x1.425107258d24dp6}, + {0x1.3fffffffffed7p-268, -0x1.425107258d226p6}, + {0x1.4p-268, -0x1.425107258d225p6}, + {0x1.3fffffffff916p-267, -0x1.411cc5f0832b4p6}, + {0x1.4p-267, -0x1.411cc5f0832abp6}, + {0x1.3fffffffffd68p-266, -0x1.3fe884bb79334p6}, + {0x1.4p-266, -0x1.3fe884bb79331p6}, + {0x1.3fffffffffe21p-265, -0x1.3eb443866f3b9p6}, + {0x1.4p-265, -0x1.3eb443866f3b7p6}, + {0x1.3fffffffffedap-264, -0x1.3d8002516543ep6}, + {0x1.4p-264, -0x1.3d8002516543dp6}, + {0x1.3fffffffffbfap-263, -0x1.3c4bc11c5b4c9p6}, + {0x1.4p-263, -0x1.3c4bc11c5b4c3p6}, + {0x1.3fffffffff862p-262, -0x1.3b177fe751554p6}, + {0x1.4p-262, -0x1.3b177fe751549p6}, + {0x1.3fffffffffa8bp-261, -0x1.39e33eb2475d6p6}, + {0x1.4p-261, -0x1.39e33eb2475cfp6}, + {0x1.3fffffffffeddp-260, -0x1.38aefd7d3d656p6}, + {0x1.4p-260, -0x1.38aefd7d3d655p6}, + {0x1.3fffffffffbfdp-259, -0x1.377abc48336ep6}, + {0x1.4p-259, -0x1.377abc48336dbp6}, + {0x1.3ffffffffff97p-258, -0x1.36467b1329762p6}, + {0x1.4p-258, -0x1.36467b1329761p6}, + {0x1.3fffffffffedfp-257, -0x1.351239de1f7e8p6}, + {0x1.4p-257, -0x1.351239de1f7e7p6}, + {0x1.3fffffffffeep-256, -0x1.33ddf8a91586ep6}, + {0x1.4p-256, -0x1.33ddf8a91586dp6}, + {0x1.3fffffffffcp-255, -0x1.32a9b7740b8f8p6}, + {0x1.4p-255, -0x1.32a9b7740b8f3p6}, + {0x1.3fffffffffd71p-254, -0x1.3175763f0197cp6}, + {0x1.4p-254, -0x1.3175763f01979p6}, + {0x1.3fffffffff588p-253, -0x1.30413509f7a0ep6}, + {0x1.4p-253, -0x1.30413509f79ffp6}, + {0x1.3fffffffff7b1p-252, -0x1.2f0cf3d4eda9p6}, + {0x1.4p-252, -0x1.2f0cf3d4eda85p6}, + {0x1.3fffffffffc03p-251, -0x1.2dd8b29fe3b1p6}, + {0x1.4p-251, -0x1.2dd8b29fe3b0bp6}, + {0x1.3fffffffff86bp-250, -0x1.2ca4716ad9b9cp6}, + {0x1.4p-250, -0x1.2ca4716ad9b91p6}, + {0x1.3fffffffffcbdp-249, -0x1.2b703035cfc1cp6}, + {0x1.4p-249, -0x1.2b703035cfc17p6}, + {0x1.3fffffffffee6p-248, -0x1.2a3bef00c5c9ep6}, + {0x1.4p-248, -0x1.2a3bef00c5c9dp6}, + {0x1.3fffffffffc06p-247, -0x1.2907adcbbbd28p6}, + {0x1.4p-247, -0x1.2907adcbbbd23p6}, + {0x1.3fffffffffd77p-246, -0x1.27d36c96b1dacp6}, + {0x1.4p-246, -0x1.27d36c96b1da9p6}, + {0x1.3fffffffffd78p-245, -0x1.269f2b61a7e32p6}, + {0x1.4p-245, -0x1.269f2b61a7e2fp6}, + {0x1.3ffffffffea0bp-244, -0x1.256aea2c9ded3p6}, + {0x1.3fffffffffee9p-244, -0x1.256aea2c9deb6p6}, + {0x1.4p-244, -0x1.256aea2c9deb5p6}, + {0x1.3fffffffffe32p-243, -0x1.2436a8f793f3ep6}, + {0x1.4p-243, -0x1.2436a8f793f3bp6}, + {0x1.3ffffffffffa3p-242, -0x1.230267c289fc2p6}, + {0x1.4p-242, -0x1.230267c289fc1p6}, + {0x1.3fffffffff591p-241, -0x1.21ce268d80056p6}, + {0x1.4p-241, -0x1.21ce268d80047p6}, + {0x1.3fffffffff9e3p-240, -0x1.2099e558760d6p6}, + {0x1.4p-240, -0x1.2099e558760cdp6}, + {0x1.3fffffffffc0cp-239, -0x1.1f65a4236c158p6}, + {0x1.4p-239, -0x1.1f65a4236c153p6}, + {0x1.3fffffffffd7dp-238, -0x1.1e3162ee621dcp6}, + {0x1.4p-238, -0x1.1e3162ee621d9p6}, + {0x1.3fffffffffd7ep-237, -0x1.1cfd21b958262p6}, + {0x1.4p-237, -0x1.1cfd21b95825fp6}, + {0x1.3fffffffffeefp-236, -0x1.1bc8e0844e2e6p6}, + {0x1.4p-236, -0x1.1bc8e0844e2e5p6}, + {0x1.3fffffffffc0fp-235, -0x1.1a949f4f4437p6}, + {0x1.4p-235, -0x1.1a949f4f4436bp6}, + {0x1.3ffffffffffa9p-234, -0x1.19605e1a3a3f1p6}, + {0x1.4p-234, -0x1.19605e1a3a3f1p6}, + {0x1.3ffffffffffaap-233, -0x1.182c1ce530478p6}, + {0x1.4p-233, -0x1.182c1ce530477p6}, + {0x1.3fffffffff2b7p-232, -0x1.16f7dbb02651p6}, + {0x1.4p-232, -0x1.16f7dbb0264fdp6}, + {0x1.3fffffffffef3p-231, -0x1.15c39a7b1c584p6}, + {0x1.4p-231, -0x1.15c39a7b1c583p6}, + {0x1.3fffffffff932p-230, -0x1.148f594612612p6}, + {0x1.4p-230, -0x1.148f594612609p6}, + {0x1.3fffffffffd84p-229, -0x1.135b181108692p6}, + {0x1.4p-229, -0x1.135b18110868fp6}, + {0x1.3fffffffffaa4p-228, -0x1.1226d6dbfe71cp6}, + {0x1.4p-228, -0x1.1226d6dbfe715p6}, + {0x1.3fffffffffef6p-227, -0x1.10f295a6f479cp6}, + {0x1.4p-227, -0x1.10f295a6f479bp6}, + {0x1.3fffffffffd86p-226, -0x1.0fbe5471ea824p6}, + {0x1.4p-226, -0x1.0fbe5471ea821p6}, + {0x1.3fffffffffd87p-225, -0x1.0e8a133ce08aap6}, + {0x1.4p-225, -0x1.0e8a133ce08a7p6}, + {0x1.3fffffffffef8p-224, -0x1.0d55d207d692ep6}, + {0x1.4p-224, -0x1.0d55d207d692dp6}, + {0x1.3fffffffffef9p-223, -0x1.0c2190d2cc9b4p6}, + {0x1.4p-223, -0x1.0c2190d2cc9b3p6}, + {0x1.3fffffffff42fp-222, -0x1.0aed4f9dc2a4ap6}, + {0x1.4p-222, -0x1.0aed4f9dc2a39p6}, + {0x1.3fffffffff658p-221, -0x1.09b90e68b8accp6}, + {0x1.4p-221, -0x1.09b90e68b8abfp6}, + {0x1.3fffffffffaaap-220, -0x1.0884cd33aeb4cp6}, + {0x1.4p-220, -0x1.0884cd33aeb45p6}, + {0x1.3fffffffffefcp-219, -0x1.07508bfea4bccp6}, + {0x1.4p-219, -0x1.07508bfea4bcbp6}, + {0x1.3fffffffffc1cp-218, -0x1.061c4ac99ac56p6}, + {0x1.4p-218, -0x1.061c4ac99ac51p6}, + {0x1.3fffffffffd8dp-217, -0x1.04e8099490cdap6}, + {0x1.4p-217, -0x1.04e8099490cd7p6}, + {0x1.3fffffffffaadp-216, -0x1.03b3c85f86d65p6}, + {0x1.3fffffffffefep-216, -0x1.03b3c85f86d5ep6}, + {0x1.4p-216, -0x1.03b3c85f86d5dp6}, + {0x1.3ffffffffdbbdp-215, -0x1.027f872a7ce16p6}, + {0x1.3fffffffffeffp-215, -0x1.027f872a7cde4p6}, + {0x1.4p-215, -0x1.027f872a7cde3p6}, + {0x1.3fffffffffc1fp-214, -0x1.014b45f572e6ep6}, + {0x1.4p-214, -0x1.014b45f572e69p6}, + {0x1.3ffffffffffb9p-213, -0x1.001704c068efp6}, + {0x1.4p-213, -0x1.001704c068eefp6}, + {0x1.3fffffffffdbfp-212, -0x1.fdc58716bdefp5}, + {0x1.4p-212, -0x1.fdc58716bdeeap5}, + {0x1.3ffffffffff3p-211, -0x1.fb5d04aca9ff8p5}, + {0x1.4p-211, -0x1.fb5d04aca9ff6p5}, + {0x1.3ffffffffffe9p-210, -0x1.f8f4824296102p5}, + {0x1.4p-210, -0x1.f8f4824296102p5}, + {0x1.3fffffffffd09p-209, -0x1.f68bffd882216p5}, + {0x1.4p-209, -0x1.f68bffd88220ep5}, + {0x1.3fffffffffdc2p-208, -0x1.f4237d6e6e32p5}, + {0x1.4p-208, -0x1.f4237d6e6e31ap5}, + {0x1.3fffffffff23fp-207, -0x1.f1bafb045a44cp5}, + {0x1.3fffffffffe7bp-207, -0x1.f1bafb045a42ap5}, + {0x1.4p-207, -0x1.f1bafb045a426p5}, + {0x1.3ffffffffffecp-206, -0x1.ef52789a46532p5}, + {0x1.4p-206, -0x1.ef52789a46532p5}, + {0x1.3fffffffffdc4p-205, -0x1.ece9f63032644p5}, + {0x1.4p-205, -0x1.ece9f6303263ep5}, + {0x1.3ffffffffe211p-204, -0x1.ea8173c61e79ep5}, + {0x1.3ffffffffff35p-204, -0x1.ea8173c61e74cp5}, + {0x1.4p-204, -0x1.ea8173c61e74ap5}, + {0x1.3ffffffffec25p-203, -0x1.e818f15c0a88ep5}, + {0x1.3fffffffffe7ep-203, -0x1.e818f15c0a85ap5}, + {0x1.4p-203, -0x1.e818f15c0a856p5}, + {0x1.3ffffffffdcadp-202, -0x1.e5b06ef1f69c5p5}, + {0x1.3fffffffffedbp-202, -0x1.e5b06ef1f6966p5}, + {0x1.4p-202, -0x1.e5b06ef1f6962p5}, + {0x1.3fffffffffd0fp-201, -0x1.e347ec87e2a76p5}, + {0x1.4p-201, -0x1.e347ec87e2a6ep5}, + {0x1.3fffffffffe8p-200, -0x1.e0df6a1dceb7ep5}, + {0x1.4p-200, -0x1.e0df6a1dceb7ap5}, + {0x1.3ffffffffff39p-199, -0x1.de76e7b3bac88p5}, + {0x1.4p-199, -0x1.de76e7b3bac86p5}, + {0x1.3fffffffffff2p-198, -0x1.dc0e6549a6d92p5}, + {0x1.4p-198, -0x1.dc0e6549a6d92p5}, + {0x1.3ffffffffff97p-197, -0x1.d9a5e2df92eap5}, + {0x1.4p-197, -0x1.d9a5e2df92e9ep5}, + {0x1.3fffffffffdcbp-196, -0x1.d73d60757efbp5}, + {0x1.4p-196, -0x1.d73d60757efaap5}, + {0x1.3ffffffffff3cp-195, -0x1.d4d4de0b6b0b8p5}, + {0x1.4p-195, -0x1.d4d4de0b6b0b6p5}, + {0x1.3fffffffffee1p-194, -0x1.d26c5ba1571c6p5}, + {0x1.4p-194, -0x1.d26c5ba1571c2p5}, + {0x1.3ffffffffff9ap-193, -0x1.d003d937432dp5}, + {0x1.4p-193, -0x1.d003d937432cep5}, + {0x1.3fffffffffdcep-192, -0x1.cd9b56cd2f3ep5}, + {0x1.4p-192, -0x1.cd9b56cd2f3dap5}, + {0x1.3fffffffffe87p-191, -0x1.cb32d4631b4eap5}, + {0x1.4p-191, -0x1.cb32d4631b4e6p5}, + {0x1.3fffffffffff8p-190, -0x1.c8ca51f9075f2p5}, + {0x1.4p-190, -0x1.c8ca51f9075f2p5}, + {0x1.3fffffffffff9p-189, -0x1.c661cf8ef36fep5}, + {0x1.4p-189, -0x1.c661cf8ef36fep5}, + {0x1.3fffffffffdd1p-188, -0x1.c3f94d24df81p5}, + {0x1.4p-188, -0x1.c3f94d24df80ap5}, + {0x1.3fffffffffe8ap-187, -0x1.c190cabacb91ap5}, + {0x1.4p-187, -0x1.c190cabacb916p5}, + {0x1.3ffffffffff43p-186, -0x1.bf284850b7a24p5}, + {0x1.4p-186, -0x1.bf284850b7a22p5}, + {0x1.3fffffffffffcp-185, -0x1.bcbfc5e6a3b2ep5}, + {0x1.4p-185, -0x1.bcbfc5e6a3b2ep5}, + {0x1.3ffffffffffa1p-184, -0x1.ba57437c8fc3cp5}, + {0x1.4p-184, -0x1.ba57437c8fc3ap5}, + {0x1.3fffffffffd79p-183, -0x1.b7eec1127bd4ep5}, + {0x1.4p-183, -0x1.b7eec1127bd46p5}, + {0x1.3fffffffffe32p-182, -0x1.b5863ea867e58p5}, + {0x1.4p-182, -0x1.b5863ea867e52p5}, + {0x1.3ffffffffe4a7p-181, -0x1.b31dbc3e53faap5}, + {0x1.3ffffffffffffp-181, -0x1.b31dbc3e53f5ep5}, + {0x1.4p-181, -0x1.b31dbc3e53f5ep5}, + {0x1.3fffffffffdd7p-180, -0x1.b0b539d44007p5}, + {0x1.4p-180, -0x1.b0b539d44006ap5}, + {0x1.3fffffffffa9bp-179, -0x1.ae4cb76a2c185p5}, + {0x1.3fffffffffe9p-179, -0x1.ae4cb76a2c17ap5}, + {0x1.4p-179, -0x1.ae4cb76a2c177p5}, + {0x1.3ffffffffe3f1p-178, -0x1.abe43500182d1p5}, + {0x1.3ffffffffff49p-178, -0x1.abe4350018284p5}, + {0x1.4p-178, -0x1.abe4350018283p5}, + {0x1.3fffffffffc69p-177, -0x1.a97bb29604398p5}, + {0x1.4p-177, -0x1.a97bb2960438fp5}, + {0x1.3fffffffffddap-176, -0x1.a713302bf04ap5}, + {0x1.4p-176, -0x1.a713302bf049bp5}, + {0x1.3fffffffffe93p-175, -0x1.a4aaadc1dc5aap5}, + {0x1.4p-175, -0x1.a4aaadc1dc5a7p5}, + {0x1.3fffffffff481p-174, -0x1.a2422b57c86d3p5}, + {0x1.3fffffffffe38p-174, -0x1.a2422b57c86b8p5}, + {0x1.4p-174, -0x1.a2422b57c86b3p5}, + {0x1.3fffffffffef1p-173, -0x1.9fd9a8edb47c2p5}, + {0x1.4p-173, -0x1.9fd9a8edb47bfp5}, + {0x1.3ffffffffffaap-172, -0x1.9d712683a08ccp5}, + {0x1.4p-172, -0x1.9d712683a08cbp5}, + {0x1.3fffffffffddep-171, -0x1.9b08a4198c9dcp5}, + {0x1.4p-171, -0x1.9b08a4198c9d7p5}, + {0x1.3ffffffffff4fp-170, -0x1.98a021af78ae4p5}, + {0x1.4p-170, -0x1.98a021af78ae3p5}, + {0x1.3fffffffffd27p-169, -0x1.96379f4564bf6p5}, + {0x1.4p-169, -0x1.96379f4564befp5}, + {0x1.3fffffffffdep-168, -0x1.93cf1cdb50dp5}, + {0x1.4p-168, -0x1.93cf1cdb50cfbp5}, + {0x1.3fffffffffe99p-167, -0x1.91669a713ce0ap5}, + {0x1.4p-167, -0x1.91669a713ce07p5}, + {0x1.3ffffffffff52p-166, -0x1.8efe180728f14p5}, + {0x1.4p-166, -0x1.8efe180728f13p5}, + {0x1.3fffffffffc72p-165, -0x1.8c95959d15028p5}, + {0x1.4p-165, -0x1.8c95959d1501fp5}, + {0x1.3ffffffffffbp-164, -0x1.8a2d13330112cp5}, + {0x1.4p-164, -0x1.8a2d13330112bp5}, + {0x1.3fffffffffd88p-163, -0x1.87c490c8ed23ep5}, + {0x1.4p-163, -0x1.87c490c8ed237p5}, + {0x1.3fffffffffe9dp-162, -0x1.855c0e5ed9346p5}, + {0x1.4p-162, -0x1.855c0e5ed9343p5}, + {0x1.3fffffffffefap-161, -0x1.82f38bf4c5452p5}, + {0x1.4p-161, -0x1.82f38bf4c544fp5}, + {0x1.3fffffffffd2ep-160, -0x1.808b098ab1562p5}, + {0x1.4p-160, -0x1.808b098ab155bp5}, + {0x1.3fffffffffe9fp-159, -0x1.7e2287209d66ap5}, + {0x1.4p-159, -0x1.7e2287209d667p5}, + {0x1.3ffffffffff58p-158, -0x1.7bba04b689774p5}, + {0x1.4p-158, -0x1.7bba04b689773p5}, + {0x1.3fffffffff099p-157, -0x1.7951824c758aap5}, + {0x1.3ffffffffff59p-157, -0x1.7951824c7588p5}, + {0x1.4p-157, -0x1.7951824c7587fp5}, + {0x1.3fffffffffd31p-156, -0x1.76e8ffe261992p5}, + {0x1.4p-156, -0x1.76e8ffe26198bp5}, + {0x1.3fffffffffdeap-155, -0x1.74807d784da9cp5}, + {0x1.4p-155, -0x1.74807d784da97p5}, + {0x1.3fffffffffea3p-154, -0x1.7217fb0e39ba6p5}, + {0x1.4p-154, -0x1.7217fb0e39ba3p5}, + {0x1.3fffffffffc7bp-153, -0x1.6faf78a425cb8p5}, + {0x1.3ffffffffff5cp-153, -0x1.6faf78a425cbp5}, + {0x1.4p-153, -0x1.6faf78a425cafp5}, + {0x1.3ffffffffffb9p-152, -0x1.6d46f63a11dbcp5}, + {0x1.4p-152, -0x1.6d46f63a11dbbp5}, + {0x1.3fffffffffa54p-151, -0x1.6ade73cffded6p5}, + {0x1.4p-151, -0x1.6ade73cffdec7p5}, + {0x1.3fffffffffbc5p-150, -0x1.6875f165e9fdfp5}, + {0x1.3fffffffffea6p-150, -0x1.6875f165e9fd6p5}, + {0x1.4p-150, -0x1.6875f165e9fd3p5}, + {0x1.3ffffffffff5fp-149, -0x1.660d6efbd60ep5}, + {0x1.4p-149, -0x1.660d6efbd60dfp5}, + {0x1.3fffffffffdefp-148, -0x1.63a4ec91c21fp5}, + {0x1.4p-148, -0x1.63a4ec91c21ebp5}, + {0x1.3fffffffffea8p-147, -0x1.613c6a27ae2fap5}, + {0x1.4p-147, -0x1.613c6a27ae2f7p5}, + {0x1.3ffffffffff61p-146, -0x1.5ed3e7bd9a404p5}, + {0x1.4p-146, -0x1.5ed3e7bd9a403p5}, + {0x1.3ffffffffff62p-145, -0x1.5c6b65538651p5}, + {0x1.4p-145, -0x1.5c6b65538650fp5}, + {0x1.3ffffffffffbfp-144, -0x1.5a02e2e97261cp5}, + {0x1.4p-144, -0x1.5a02e2e97261bp5}, + {0x1.3fffffffffcdfp-143, -0x1.579a607f5e73p5}, + {0x1.4p-143, -0x1.579a607f5e727p5}, + {0x1.3fffffffffd98p-142, -0x1.5531de154a83ap5}, + {0x1.4p-142, -0x1.5531de154a833p5}, + {0x1.3fffffffffe51p-141, -0x1.52c95bab36944p5}, + {0x1.4p-141, -0x1.52c95bab3693fp5}, + {0x1.3ffffffffffc2p-140, -0x1.5060d94122a4cp5}, + {0x1.4p-140, -0x1.5060d94122a4bp5}, + {0x1.3fffffffffdf6p-139, -0x1.4df856d70eb5cp5}, + {0x1.4p-139, -0x1.4df856d70eb57p5}, + {0x1.3fffffffffeafp-138, -0x1.4b8fd46cfac66p5}, + {0x1.4p-138, -0x1.4b8fd46cfac63p5}, + {0x1.3ffffffffff68p-137, -0x1.49275202e6d7p5}, + {0x1.4p-137, -0x1.49275202e6d6fp5}, + {0x1.3ffffffffffc5p-136, -0x1.46becf98d2e7bp5}, + {0x1.4p-136, -0x1.46becf98d2e7bp5}, + {0x1.3fffffffffdf9p-135, -0x1.44564d2ebef8cp5}, + {0x1.4p-135, -0x1.44564d2ebef87p5}, + {0x1.3fffffffffeb2p-134, -0x1.41edcac4ab096p5}, + {0x1.4p-134, -0x1.41edcac4ab093p5}, + {0x1.3ffffffffff6bp-133, -0x1.3f85485a971ap5}, + {0x1.4p-133, -0x1.3f85485a9719fp5}, + {0x1.3ffffffffe699p-132, -0x1.3d1cc5f0832f2p5}, + {0x1.3ffffffffff1p-132, -0x1.3d1cc5f0832aep5}, + {0x1.4p-132, -0x1.3d1cc5f0832abp5}, + {0x1.3ffffffffffc9p-131, -0x1.3ab443866f3b8p5}, + {0x1.4p-131, -0x1.3ab443866f3b7p5}, + {0x1.3fffffffffda1p-130, -0x1.384bc11c5b4cap5}, + {0x1.4p-130, -0x1.384bc11c5b4c3p5}, + {0x1.3ffffffffed15p-129, -0x1.35e33eb247604p5}, + {0x1.3ffffffffff6ep-129, -0x1.35e33eb2475dp5}, + {0x1.4p-129, -0x1.35e33eb2475cfp5}, + {0x1.3ffffffffdd9dp-128, -0x1.337abc483373bp5}, + {0x1.3fffffffffd46p-128, -0x1.337abc48336e2p5}, + {0x1.4p-128, -0x1.337abc48336dbp5}, + {0x1.3fffffffffdffp-127, -0x1.311239de1f7ecp5}, + {0x1.4p-127, -0x1.311239de1f7e7p5}, + {0x1.3fffffffff391p-126, -0x1.2ea9b7740b916p5}, + {0x1.3ffffffffff7p-126, -0x1.2ea9b7740b8f4p5}, + {0x1.4p-126, -0x1.2ea9b7740b8f3p5}, + {0x1.3ffffffffff71p-125, -0x1.2c413509f7ap5}, + {0x1.4p-125, -0x1.2c413509f79ffp5}, + {0x1.3fffffffffc91p-124, -0x1.29d8b29fe3b14p5}, + {0x1.4p-124, -0x1.29d8b29fe3b0bp5}, + {0x1.3fffffffffd4ap-123, -0x1.27703035cfc1ep5}, + {0x1.4p-123, -0x1.27703035cfc17p5}, + {0x1.3fffffffffe03p-122, -0x1.2507adcbbbd28p5}, + {0x1.4p-122, -0x1.2507adcbbbd23p5}, + {0x1.3fffffffffebcp-121, -0x1.229f2b61a7e32p5}, + {0x1.4p-121, -0x1.229f2b61a7e2fp5}, + {0x1.3ffffffffff19p-120, -0x1.2036a8f793f3ep5}, + {0x1.4p-120, -0x1.2036a8f793f3bp5}, + {0x1.3fffffffffd4dp-119, -0x1.1dce268d8004ep5}, + {0x1.4p-119, -0x1.1dce268d80047p5}, + {0x1.3fffffffffebep-118, -0x1.1b65a4236c156p5}, + {0x1.4p-118, -0x1.1b65a4236c153p5}, + {0x1.3ffffffffff77p-117, -0x1.18fd21b95826p5}, + {0x1.4p-117, -0x1.18fd21b95825fp5}, + {0x1.3ffffffffffd4p-116, -0x1.16949f4f4436bp5}, + {0x1.4p-116, -0x1.16949f4f4436bp5}, + {0x1.3fffffffffe08p-115, -0x1.142c1ce53047cp5}, + {0x1.4p-115, -0x1.142c1ce530477p5}, + {0x1.3fffffffffe09p-114, -0x1.11c39a7b1c588p5}, + {0x1.4p-114, -0x1.11c39a7b1c583p5}, + {0x1.3fffffffffec2p-113, -0x1.0f5b181108692p5}, + {0x1.4p-113, -0x1.0f5b18110868fp5}, + {0x1.3ffffffffff7bp-112, -0x1.0cf295a6f479cp5}, + {0x1.4p-112, -0x1.0cf295a6f479bp5}, + {0x1.3ffffffffffd8p-111, -0x1.0a8a133ce08a8p5}, + {0x1.4p-111, -0x1.0a8a133ce08a7p5}, + {0x1.3fffffffffa73p-110, -0x1.082190d2cc9c2p5}, + {0x1.4p-110, -0x1.082190d2cc9b3p5}, + {0x1.3fffffffffec5p-109, -0x1.05b90e68b8ac2p5}, + {0x1.4p-109, -0x1.05b90e68b8abfp5}, + {0x1.3ffffffffedddp-108, -0x1.03508bfea4bfep5}, + {0x1.3ffffffffff7ep-108, -0x1.03508bfea4bccp5}, + {0x1.4p-108, -0x1.03508bfea4bcbp5}, + {0x1.3ffffffffde65p-107, -0x1.00e8099490d35p5}, + {0x1.3fffffffffe0ep-107, -0x1.00e8099490cdcp5}, + {0x1.4p-107, -0x1.00e8099490cd7p5}, + {0x1.3ffffffffed3dp-106, -0x1.fcff0e54f9c2fp4}, + {0x1.3fffffffffe82p-106, -0x1.fcff0e54f9bcep4}, + {0x1.4p-106, -0x1.fcff0e54f9bc6p4}, + {0x1.3fffffffffff3p-105, -0x1.f82e0980d1ddep4}, + {0x1.4p-105, -0x1.f82e0980d1ddep4}, + {0x1.3ffffffffff98p-104, -0x1.f35d04aca9ff8p4}, + {0x1.4p-104, -0x1.f35d04aca9ff6p4}, + {0x1.3ffffffffe3b7p-103, -0x1.ee8bffd8822abp4}, + {0x1.3ffffffffffc7p-103, -0x1.ee8bffd88221p4}, + {0x1.4p-103, -0x1.ee8bffd88220ep4}, + {0x1.3fffffffffdcdp-102, -0x1.e9bafb045a432p4}, + {0x1.4p-102, -0x1.e9bafb045a426p4}, + {0x1.3ffffffffff3ep-101, -0x1.e4e9f63032642p4}, + {0x1.4p-101, -0x1.e4e9f6303263ep4}, + {0x1.3ffffffffe301p-100, -0x1.e018f15c0a8f8p4}, + {0x1.3fffffffffff7p-100, -0x1.e018f15c0a856p4}, + {0x1.4p-100, -0x1.e018f15c0a856p4}, + {0x1.3fffffffffd73p-99, -0x1.db47ec87e2a7cp4}, + {0x1.4p-99, -0x1.db47ec87e2a6ep4}, + {0x1.3ffffffffdd9dp-98, -0x1.d676e7b3bad46p4}, + {0x1.3fffffffffee4p-98, -0x1.d676e7b3bac8cp4}, + {0x1.4p-98, -0x1.d676e7b3bac86p4}, + {0x1.3ffffffffff9dp-97, -0x1.d1a5e2df92eap4}, + {0x1.4p-97, -0x1.d1a5e2df92e9ep4}, + {0x1.3fffffffffffap-96, -0x1.ccd4de0b6b0b6p4}, + {0x1.4p-96, -0x1.ccd4de0b6b0b6p4}, + {0x1.3ffffffffffcdp-95, -0x1.c803d937432dp4}, + {0x1.4p-95, -0x1.c803d937432cep4}, + {0x1.3ffffffffffcep-94, -0x1.c332d4631b4e8p4}, + {0x1.4p-94, -0x1.c332d4631b4e6p4}, + {0x1.3fffffffffe8cp-93, -0x1.be61cf8ef3706p4}, + {0x1.4p-93, -0x1.be61cf8ef36fep4}, + {0x1.3fffffffff983p-92, -0x1.b990cabacb93ap4}, + {0x1.3ffffffffff45p-92, -0x1.b990cabacb91ap4}, + {0x1.4p-92, -0x1.b990cabacb916p4}, + {0x1.3fffffffffffep-91, -0x1.b4bfc5e6a3b2ep4}, + {0x1.4p-91, -0x1.b4bfc5e6a3b2ep4}, + {0x1.3fffffffffdd6p-90, -0x1.afeec1127bd52p4}, + {0x1.4p-90, -0x1.afeec1127bd46p4}, + {0x1.3fffffffffeebp-89, -0x1.ab1dbc3e53f64p4}, + {0x1.4p-89, -0x1.ab1dbc3e53f5ep4}, + {0x1.3ffffffffffa4p-88, -0x1.a64cb76a2c178p4}, + {0x1.4p-88, -0x1.a64cb76a2c177p4}, + {0x1.3fffffffffa9bp-87, -0x1.a17bb296043acp4}, + {0x1.3fffffffffd7cp-87, -0x1.a17bb2960439cp4}, + {0x1.4p-87, -0x1.a17bb2960438fp4}, + {0x1.3fffffffffe91p-86, -0x1.9caaadc1dc5aep4}, + {0x1.3ffffffffffc5p-86, -0x1.9caaadc1dc5a8p4}, + {0x1.3fffffffffe36p-85, -0x1.97d9a8edb47c8p4}, + {0x1.3ffffffffffa7p-84, -0x1.9308a4198c9d8p4}, + {0x1.3ffffffffff7ap-83, -0x1.8e379f4564bf2p4}, + {0x1.3ffffffffffd7p-82, -0x1.89669a713ce08p4}, + {0x1.3fffffffffe95p-81, -0x1.8495959d15026p4}, + {0x1.3ffffffffff4ep-80, -0x1.7fc490c8ed23ap4}, + {0x1.3ffffffffeafbp-79, -0x1.7af38bf4c54c3p4}, + {0x1.3ffffffffffd9p-79, -0x1.7af38bf4c544fp4}, + {0x1.3fffffffffe3bp-78, -0x1.762287209d67p4}, + {0x1.3ffffffffde65p-77, -0x1.7151824c7593ap4}, + {0x1.3fffffffffef4p-77, -0x1.7151824c75884p4}, + {0x1.3ffffffffffadp-76, -0x1.6c807d784da98p4}, + {0x1.3fffffffffb8bp-75, -0x1.67af78a425cc7p4}, + {0x1.3ffffffffffaep-75, -0x1.67af78a425cbp4}, + {0x1.3ffffffffffddp-74, -0x1.62de73cffdec8p4}, + {0x1.3fffffffffe3fp-73, -0x1.5e0d6efbd60e8p4}, + {0x1.3ffffffffff54p-72, -0x1.593c6a27ae2fap4}, + {0x1.3ffffffffffb1p-71, -0x1.546b65538651p4}, + {0x1.3fffffffff571p-70, -0x1.4f9a607f5e762p4}, + {0x1.3fffffffffde5p-70, -0x1.4f9a607f5e732p4}, + {0x1.3fffffffffe9ep-69, -0x1.4ac95bab36946p4}, + {0x1.3ffffffffffb3p-68, -0x1.45f856d70eb58p4}, + {0x1.3ffffffffe1d7p-67, -0x1.41275202e6e16p4}, + {0x1.3ffffffffffb4p-67, -0x1.41275202e6d7p4}, + {0x1.3fffffffffe44p-66, -0x1.3c564d2ebef9p4}, + {0x1.3fffffffffd5fp-65, -0x1.3785485a971aep4}, + {0x1.3fffffffffaadp-64, -0x1.32b443866f3d5p4}, + {0x1.3fffffffffefep-64, -0x1.32b443866f3bcp4}, + {0x1.3ffffffffeb35p-63, -0x1.2de33eb247643p4}, + {0x1.3ffffffffffb7p-63, -0x1.2de33eb2475dp4}, + {0x1.3ffffffffffe6p-62, -0x1.291239de1f7e8p4}, + {0x1.3fffffffffdecp-61, -0x1.24413509f7a0ap4}, + {0x1.3ffffffffff5dp-60, -0x1.1f703035cfc1ap4}, + {0x1.3ffffffffffbap-59, -0x1.1a9f2b61a7e3p4}, + {0x1.3fffffffffd92p-58, -0x1.15ce268d80054p4}, + {0x1.3ffffffffff03p-57, -0x1.10fd21b958264p4}, + {0x1.3ffffffffe6e9p-56, -0x1.0c2c1ce530503p4}, + {0x1.3ffffffffffbcp-56, -0x1.0c2c1ce530478p4}, + {0x1.3ffffffffe2c7p-55, -0x1.075b181108731p4}, + {0x1.3ffffffffff61p-55, -0x1.075b181108692p4}, + {0x1.3ffffffffffecp-54, -0x1.028a133ce08a8p4}, + {0x1.3fffffffff14fp-53, -0x1.fb721cd171621p3}, + {0x1.3fffffffffff8p-53, -0x1.fb721cd17157ep3}, + {0x1.3ffffffffdd9dp-52, -0x1.f1d0132921b2dp3}, + {0x1.3ffffffffffe2p-52, -0x1.f1d01329219bp3}, + {0x1.3ffffffffebebp-51, -0x1.e82e0980d1ebdp3}, + {0x1.3fffffffffe2dp-51, -0x1.e82e0980d1df2p3}, + {0x1.3ffffffffff7p-50, -0x1.de8bffd882214p3}, + {0x1.3fffffffffaadp-49, -0x1.d4e9f6303267ap3}, + {0x1.3ffffffffffcdp-49, -0x1.d4e9f6303264p3}, + {0x1.3fffffffffd77p-48, -0x1.cb47ec87e2a8ap3}, + {0x1.3fffffffffda5p-48, -0x1.cb47ec87e2a89p3}, + {0x1.3ffffffffff16p-47, -0x1.c1a5e2df92ea8p3}, + {0x1.3fffffffff983p-46, -0x1.b803d93743316p3}, + {0x1.3ffffffffffcfp-46, -0x1.b803d937432dp3}, + {0x1.3ffffffffffa2p-45, -0x1.ae61cf8ef3702p3}, + {0x1.3fffffffffbc5p-44, -0x1.a4bfc5e6a3b5ep3}, + {0x1.3ffffffffffffp-44, -0x1.a4bfc5e6a3b2ep3}, + {0x1.3fffffffffdd7p-43, -0x1.9b1dbc3e53f76p3}, + {0x1.3fffffffffebep-42, -0x1.917bb2960439cp3}, + {0x1.3ffffffffe3f1p-41, -0x1.87d9a8edb48f7p3}, + {0x1.3ffffffffff77p-41, -0x1.87d9a8edb47c4p3}, + {0x1.3fffffffff23fp-40, -0x1.7e379f4564c87p3}, + {0x1.3ffffffffffbdp-40, -0x1.7e379f4564bf2p3}, + {0x1.3fffffffffe36p-39, -0x1.7495959d15032p3}, + {0x1.3ffffffffecdbp-38, -0x1.6af38bf4c5523p3}, + {0x1.3ffffffffffa7p-38, -0x1.6af38bf4c5452p3}, + {0x1.3ffffffffffd6p-37, -0x1.6151824c7588p3}, + {0x1.3ffffffffffeep-36, -0x1.57af78a425cafp3}, + {0x1.3ffffffffdcadp-35, -0x1.4e0d6efbd6268p3}, + {0x1.3ffffffffffefp-35, -0x1.4e0d6efbd60ep3}, + {0x1.3fffffffffe68p-34, -0x1.446b65538652p3}, + {0x1.3ffffffffeafbp-33, -0x1.3ac95bab36a28p3}, + {0x1.3ffffffffffd9p-33, -0x1.3ac95bab3694p3}, + {0x1.3ffffffffffdap-32, -0x1.31275202e6d7p3}, + {0x1.3fffffffffcb5p-31, -0x1.2785485a971c4p3}, + {0x1.3ffffffffffc4p-31, -0x1.2785485a971a2p3}, + {0x1.3fffffffffec7p-30, -0x1.1de33eb2475dcp3}, + {0x1.3ffffffffffaep-29, -0x1.14413509f7a02p3}, + {0x1.3ffffffffd9a3p-28, -0x1.0a9f2b61a7fd9p3}, + {0x1.3ffffffffffddp-28, -0x1.0a9f2b61a7e3p3}, + {0x1.3fffffffff32fp-27, -0x1.00fd21b9582edp3}, + {0x1.3fffffffffe6dp-27, -0x1.00fd21b95827p3}, + {0x1.3ffffffffffe4p-26, -0x1.eeb6302210d2p2}, + {0x1.3ffffffffeb35p-25, -0x1.db721cd17174dp2}, + {0x1.3fffffffffffcp-25, -0x1.db721cd17157ep2}, + {0x1.3ffffffffde65p-24, -0x1.c82e0980d20cap2}, + {0x1.3fffffffffeafp-24, -0x1.c82e0980d1dfcp2}, + {0x1.3ffffffffed3dp-23, -0x1.b4e9f630327ep2}, + {0x1.3ffffffffff7fp-23, -0x1.b4e9f6303264ap2}, + {0x1.3ffffffffffdcp-22, -0x1.a1a5e2df92ea2p2}, + {0x1.3ffffffffe91bp-21, -0x1.8e61cf8ef38fbp2}, + {0x1.3ffffffffffffp-21, -0x1.8e61cf8ef36fep2}, + {0x1.3fffffffffeb2p-20, -0x1.7b1dbc3e53f7bp2}, + {0x1.3ffffffffe3b7p-19, -0x1.67d9a8edb4a33p2}, + {0x1.3ffffffffff3dp-19, -0x1.67d9a8edb47dp2}, + {0x1.3ffffffffe6e9p-18, -0x1.5495959d1524dp2}, + {0x1.3fffffffffff6p-18, -0x1.5495959d1502p2}, + {0x1.3ffffffffdb5bp-17, -0x1.4151824c75badp2}, + {0x1.3ffffffffffebp-17, -0x1.4151824c7588p2}, + {0x1.3ffffffffe301p-16, -0x1.2e0d6efbd6364p2}, + {0x1.3ffffffffff11p-16, -0x1.2e0d6efbd60f3p2}, + {0x1.3fffffffff14fp-15, -0x1.1ac95bab36a85p2}, + {0x1.3ffffffffff57p-15, -0x1.1ac95bab3694ep2}, + {0x1.3fffffffff481p-14, -0x1.0785485a9729fp2}, + {0x1.3fffffffffff9p-14, -0x1.0785485a971ap2}, + {0x1.3fffffffff571p-13, -0x1.e8826a13ef5d4p1}, + {0x1.3fffffffffff1p-13, -0x1.e8826a13ef4p1}, + {0x1.3fffffffffc7bp-12, -0x1.c1fa4372b055ap1}, + {0x1.3ffffffffffcfp-12, -0x1.c1fa4372b04c6p1}, + {0x1.3fffffffff189p-11, -0x1.9b721cd171802p1}, + {0x1.3fffffffffffep-11, -0x1.9b721cd17157ep1}, + {0x1.3ffffffffe211p-10, -0x1.74e9f63032b72p1}, + {0x1.3fffffffffff3p-10, -0x1.74e9f6303264p1}, + {0x1.3fffffffffbc5p-9, -0x1.4e61cf8ef37bbp1}, + {0x1.3fffffffffff4p-9, -0x1.4e61cf8ef37p1}, + {0x1.3fffffffff391p-8, -0x1.27d9a8edb49e8p1}, + {0x1.3ffffffffffe9p-8, -0x1.27d9a8edb47c2p1}, + {0x1.3fffffffffaadp-7, -0x1.0151824c7596cp1}, + {0x1.3ffffffffffeap-7, -0x1.0151824c75882p1}, + {0x1.3fffffffffc7bp-6, -0x1.b592b7566d3b6p0}, + {0x1.3fffffffffff2p-6, -0x1.b592b7566d282p0}, + {0x1.3fffffffffda5p-5, -0x1.68826a13ef4dp0}, + {0x1.3fffffffffff6p-5, -0x1.68826a13ef402p0}, + {0x1.3fffffffffb8bp-4, -0x1.1b721cd17170ap0}, + {0x1.3ffffffffffffp-4, -0x1.1b721cd17157ep0}, + {0x1.3fffffffffcb5p-3, -0x1.9cc39f1de7047p-1}, + {0x1.3fffffffffff2p-3, -0x1.9cc39f1de6e06p-1}, + {0x1.3fffffffffc7bp-2, -0x1.02a30498eb36fp-1}, + {0x1.4p-2, -0x1.02a30498eb0fep-1}, + {0x1.3fffffffffda5p-1, -0x1.a209a84fbd684p-3}, + {0x1.3fffffffffffcp-1, -0x1.a209a84fbd002p-3}, + {0x1.3fffffffffff3p0, 0x1.8cf18388647c5p-4}, + {0x1.3fffffffffffdp0, 0x1.8cf18388647fbp-4}, + {0x1.3ffffffffff7bp1, 0x1.977d95ec10b4ap-2}, + {0x1.3fffffffffffcp1, 0x1.977d95ec10bfcp-2}, + {0x1.3ffffffffff2bp2, 0x1.65df657b0426dp-1}, + {0x1.3fffffffffff3p2, 0x1.65df657b042f8p-1}, + {0x1.3fffffffffc83p4, 0x1.4d104d427dd4ap0}, + {0x1.3fffffffffff1p4, 0x1.4d104d427de7ap0}, + {0x1.4p4, 0x1.4d104d427de8p0}, + {0x1.3ffffffffff2bp5, 0x1.9a209a84fbcb6p0}, + {0x1.4p5, 0x1.9a209a84fbdp0}, + {0x1.3fffffffffd23p6, 0x1.e730e7c779a81p0}, + {0x1.3fffffffffffep6, 0x1.e730e7c779b7ep0}, + {0x1.4p6, 0x1.e730e7c779b7fp0}, + {0x1.3ffffffffece3p7, 0x1.1a209a84fb9aep1}, + {0x1.4p7, 0x1.1a209a84fbdp1}, + {0x1.3fffffffffeb3p8, 0x1.40a8c1263ac06p1}, + {0x1.3ffffffffff71p8, 0x1.40a8c1263ac26p1}, + {0x1.4p8, 0x1.40a8c1263ac3fp1}, + {0x1.3fffffffffe3bp9, 0x1.6730e7c779b31p1}, + {0x1.3fffffffffffcp9, 0x1.6730e7c779b7ep1}, + {0x1.4p9, 0x1.6730e7c779b7fp1}, + {0x1.3fffffffff657p10, 0x1.8db90e68b8912p1}, + {0x1.3ffffffffff67p10, 0x1.8db90e68b8aa4p1}, + {0x1.4p10, 0x1.8db90e68b8abfp1}, + {0x1.3fffffffff8ffp11, 0x1.b4413509f78c8p1}, + {0x1.3ffffffffffecp11, 0x1.b4413509f79fcp1}, + {0x1.4p11, 0x1.b4413509f79ffp1}, + {0x1.3fffffffffd23p12, 0x1.dac95bab368cp1}, + {0x1.3ffffffffff5dp12, 0x1.dac95bab36922p1}, + {0x1.4p12, 0x1.dac95bab3693fp1}, + {0x1.3fffffffffe13p13, 0x1.00a8c1263ac15p2}, + {0x1.3fffffffffee2p13, 0x1.00a8c1263ac26p2}, + {0x1.4p13, 0x1.00a8c1263ac3fp2}, + {0x1.3fffffffff193p14, 0x1.13ecd476da29fp2}, + {0x1.3ffffffffffc9p14, 0x1.13ecd476da3dap2}, + {0x1.4p14, 0x1.13ecd476da3dfp2}, + {0x1.3fffffffff5b7p15, 0x1.2730e7c779a9bp2}, + {0x1.3ffffffffff1dp15, 0x1.2730e7c779b6cp2}, + {0x1.4p15, 0x1.2730e7c779b7fp2}, + {0x1.3ffffffffec2fp16, 0x1.3a74fb1819167p2}, + {0x1.3ffffffffffedp16, 0x1.3a74fb181931ep2}, + {0x1.4p16, 0x1.3a74fb181931fp2}, + {0x1.3fffffffffb07p17, 0x1.4db90e68b8a51p2}, + {0x1.3fffffffffecep17, 0x1.4db90e68b8aa4p2}, + {0x1.4p17, 0x1.4db90e68b8abfp2}, + {0x1.3ffffffffff2bp18, 0x1.60fd21b95824dp2}, + {0x1.3ffffffffffb5p18, 0x1.60fd21b958258p2}, + {0x1.4p18, 0x1.60fd21b95825fp2}, + {0x1.3ffffffffffe4p19, 0x1.74413509f79fcp2}, + {0x1.4p19, 0x1.74413509f79ffp2}, + {0x1.3fffffffff6cfp20, 0x1.8785485a970d3p2}, + {0x1.3ffffffffffd9p20, 0x1.8785485a9719cp2}, + {0x1.4p20, 0x1.8785485a9719fp2}, + {0x1.3ffffffffed47p21, 0x1.9ac95bab3679fp2}, + {0x1.3fffffffffebap21, 0x1.9ac95bab36922p2}, + {0x1.4p21, 0x1.9ac95bab3693fp2}, + {0x1.3fffffffff16bp22, 0x1.ae0d6efbd5f9bp2}, + {0x1.3ffffffffff8ap22, 0x1.ae0d6efbd60d4p2}, + {0x1.4p22, 0x1.ae0d6efbd60dfp2}, + {0x1.3ffffffffe667p23, 0x1.c151824c75646p2}, + {0x1.3fffffffffffep23, 0x1.c151824c7587ep2}, + {0x1.4p23, 0x1.c151824c7587fp2}, + {0x1.3fffffffffff3p24, 0x1.d495959d1501ep2}, + {0x1.4p24, 0x1.d495959d1501fp2}, + {0x1.3fffffffffadfp25, 0x1.e7d9a8edb474dp2}, + {0x1.3fffffffffebdp25, 0x1.e7d9a8edb47a2p2}, + {0x1.4p25, 0x1.e7d9a8edb47bfp2}, + }; + + for (double[] testCase: testCases) + failures+=testLog10Case(testCase[0], testCase[1]); + + return failures; + } + + public static void main(String [] argv) { + int failures = 0; + + failures += testLog10(); + + if (failures > 0) { + System.err.println("Testing log10 incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:13:01 2009 +++ new/test/java/lang/StrictMath/Log1pTests.java Mon Jan 26 16:13:00 2009 @@ -0,0 +1,210 @@ +/* + * 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 4851638 + * @summary Tests for StrictMath.log1p + * @author Joseph D. Darcy + */ + +/** + * The tests in ../Math/Log1pTests.java test properties that should + * hold for any log1p implementation, including the FDLIBM-based one + * required for StrictMath.log1p. Therefore, the test cases in + * ../Math/Log1pTests.java are run against both the Math and + * StrictMath versions of log1p. The role of this test is to verify + * that the FDLIBM log1p algorithm is being used by running golden + * file tests on values that may vary from one conforming log1p + * implementation to another. + */ + +public class Log1pTests { + private Log1pTests(){} + + static int testLog1pCase(double input, double expected) { + return Tests.test("StrictMath.log1p(double)", input, + StrictMath.log1p(input), expected); + } + + static int testLog1p() { + int failures = 0; + + double [][] testCases = { + {0x1.fffffffffffffp-54, 0x1.fffffffffffffp-54}, + {0x1.fffffffffcc48p-15, 0x1.fffc000aa74f3p-15}, + {0x1.ffffffffff224p-14, 0x1.fff8002aa8ccfp-14}, + {0x1.ffffffffff90cp-13, 0x1.fff000aaa23bdp-13}, + {0x1.fffffffffffcep-4, 0x1.e27076e2af2bap-4}, + {0x1.fffffffffffffp-2, 0x1.9f323ecbf984bp-2}, + {0x1.ffffffffffffdp-1, 0x1.62e42fefa39eep-1}, + {0x1.0p1, 0x1.193ea7aad030ap0}, + {0x1.ffffffffffffbp1, 0x1.9c041f7ed8d31p0}, + {0x1.fffffffffffffp2, 0x1.193ea7aad030ap1}, + {0x1.fffffffffffe1p3, 0x1.6aa6bc1fa7f73p1}, + {0x1.fffffffffffe1p4, 0x1.bf8d8f4d5b8cap1}, + {0x1.ffffffffffff1p5, 0x1.0b29293942974p2}, + {0x1.fffffffffff41p6, 0x1.37072a9b5b6b4p2}, + {0x1.ffffffffffe65p7, 0x1.63241004e8fdep2}, + {0x1.ffffffffffca1p8, 0x1.8f60adf041b73p2}, + {0x1.fffffffffffffp9, 0x1.bbad39ebe1ccp2}, + {0x1.fffffffffffffp10, 0x1.e801c1698ba43p2}, + {0x1.ffffffffff2dep11, 0x1.0a2d23e3bb54bp3}, + {0x1.ffffffffff18dp12, 0x1.205a66eeb4f81p3}, + {0x1.ffffffffffff9p13, 0x1.368829f0af2dcp3}, + {0x1.fffffffffbc1ep14, 0x1.4cb62cf069217p3}, + {0x1.ffffffffffff5p16, 0x1.791282ee99d8ep3}, + {0x1.fffffffffba46p17, 0x1.8f40bded96cd1p3}, + {0x1.ffffffffffff7p18, 0x1.a56efcec920cbp3}, + {0x1.ffffffffffff7p19, 0x1.bb9d3deb8c76ap3}, + {0x1.ffffffffffff9p20, 0x1.d1cb7fea86bcap3}, + {0x1.ffffffffffff7p24, 0x1.1542457b37d42p4}, + {0x1.fffffffffffe7p29, 0x1.4cb5ecf0e964fp4}, + {0x1.ffffffffffff9p30, 0x1.57cd0e704682p4}, + {0x1.ffffffffffffbp34, 0x1.8429946e1cf5dp4}, + {0x1.fffffffffffedp35, 0x1.8f40b5ed9912dp4}, + {0x1.fffffffffffefp39, 0x1.bb9d3beb8c96ap4}, + {0x1.fffffffffffe1p40, 0x1.c6b45d6b09abap4}, + {0x1.fffffffffffe3p44, 0x1.f310e368fe17fp4}, + {0x1.ffffffffffff5p45, 0x1.fe2804e87b34cp4}, + {0x1.fffffffffffc5p66, 0x1.7386e22edf4a5p5}, + {0x1.fffffffffff98p90, 0x1.f89c7428bca5fp5}, + {0x1.a36e2eb1c317dp-14, 0x1.a368d0657ee51p-14}, + {0x1.0624dd2f18d5cp-10, 0x1.060354f8c2226p-10}, + {0x1.ffffffffffffdp-1, 0x1.62e42fefa39eep-1}, + {0x1.8ffffffffffccp6, 0x1.275e2271bba28p2}, + {0x1.f3fffffffff1p9, 0x1.ba2909ce4f846p2}, + {0x1.387ffffffffa8p13, 0x1.26bbed6fbd838p3}, + {0x1.869ffffffffe4p16, 0x1.7069f7a2d94f4p3}, + {0x1.e847fffffff3ep19, 0x1.ba18abb1dedbcp3}, + {0x1.312cfffffff23p23, 0x1.01e3b85ec299p4}, + {0x1.7d783ffffff17p26, 0x1.26bb1bbe0482ap4}, + {0x1.dcd64ffffffcep29, 0x1.4b927f3304b3ap4}, + {0x1.2a05f1ffffa3p33, 0x1.7069e2aa317fep4}, + {0x1.74876e7ffffbep36, 0x1.9541462195ffap4}, + {0x1.d1a94a1fffddp39, 0x1.ba18a999000a6p4}, + {0x1.2309ce53ffed2p43, 0x1.def00d106aa4ep4}, + {0x1.6bcc41e8ffe73p46, 0x1.01e3b843eaa6cp5}, + {0x1.c6bf52633fe7dp49, 0x1.144f69ff9ffbep5}, + {0x1.1c37937e07fffp53, 0x1.26bb1bbb55515p5}, + {0x1.6345785d89f12p56, 0x1.3926cd770aa62p5}, + {0x1.bc16d674ec76ap59, 0x1.4b927f32bffb6p5}, + {0x1.158e460913c51p63, 0x1.5dfe30ee75504p5}, + {0x1.5af1d78b58badp66, 0x1.7069e2aa2aa58p5}, + {0x1.b1ae4d6e2ecd4p69, 0x1.82d59465dffap5}, + {0x1.0f0cf064dd066p73, 0x1.95414621954d6p5}, + {0x1.52d02c7e14a9p76, 0x1.a7acf7dd4aa4cp5}, + {0x1.a784379d99c19p79, 0x1.ba18a998fff98p5}, + {0x1.08b2a2c27fb5p83, 0x1.cc845b54b54bap5}, + {0x1.4adf4b7320322p86, 0x1.def00d106aa42p5}, + {0x1.9d971e4fe7b91p89, 0x1.f15bbecc1ff6ap5}, + {0x1.027e72f1f0ea3p93, 0x1.01e3b843eaa63p6}, + {0x1.431e0fae6d44bp96, 0x1.0b199121c5512p6}, + {0x1.93e5939a086bcp99, 0x1.144f69ff9ffb4p6}, + {0x1.f8def8808ac86p102, 0x1.1d8542dd7aa65p6}, + {0x1.3b8b5b5056dc7p106, 0x1.26bb1bbb55514p6}, + {0x1.8a6e32246c76cp109, 0x1.2ff0f4992ffb8p6}, + {0x1.ed09bead86a07p112, 0x1.3926cd770aa41p6}, + {0x1.3426172c74d33p116, 0x1.425ca654e550ep6}, + {0x1.812f9cf791f1ep119, 0x1.4b927f32bffb4p6}, + {0x1.e17b8435758f2p122, 0x1.54c858109aa3ep6}, + {0x1.2ced32a169cfap126, 0x1.5dfe30ee754fap6}, + {0x1.78287f49c497cp129, 0x1.673409cc4ffbp6}, + {0x1.d6329f1c3492ep132, 0x1.7069e2aa2aa3p6}, + {0x1.25dfa371a14b8p136, 0x1.799fbb88054f2p6}, + {0x1.6f578c4e09f0ap139, 0x1.82d59465dffa8p6}, + {0x1.cb2d6f618c4b4p142, 0x1.8c0b6d43baa4cp6}, + {0x1.1efc659cf77abp146, 0x1.95414621954eap6}, + {0x1.66bb7f0435c5bp149, 0x1.9e771eff6ffa6p6}, + {0x1.c06a5ec5428a4p152, 0x1.a7acf7dd4aa36p6}, + {0x1.18427b3b49fc9p156, 0x1.b0e2d0bb254f6p6}, + {0x1.5e531a0a1c729p159, 0x1.ba18a998fff9cp6}, + {0x1.b5e7e08ca3686p162, 0x1.c34e8276daa4p6}, + {0x1.11b0ec57e6492p166, 0x1.cc845b54b54f2p6}, + {0x1.561d276ddfd7dp169, 0x1.d5ba34328ff9ap6}, + {0x1.aba471495757bp172, 0x1.def00d106aa3p6}, + {0x1.0b46c6cdd6a8ep176, 0x1.e825e5ee454ddp6}, + {0x1.4e1878814c5f4p179, 0x1.f15bbecc1ff88p6}, + {0x1.a19e96a19f65ap182, 0x1.fa9197a9faa2ep6}, + {0x1.05031e2503cfcp186, 0x1.01e3b843eaa71p7}, + {0x1.4643e5ae441d2p189, 0x1.067ea4b2d7fb6p7}, + {0x1.97d4df19d5c5dp192, 0x1.0b199121c5516p7}, + {0x1.fdca16e04ae24p195, 0x1.0fb47d90b2a65p7}, + {0x1.3e9e4e4c2f2dap199, 0x1.144f69ff9ffc4p7}, + {0x1.8e45e1df3ac31p202, 0x1.18ea566e8d514p7}, + {0x1.f1d75a5709306p205, 0x1.1d8542dd7aa63p7}, + {0x1.372698766608cp209, 0x1.22202f4c67fcp7}, + {0x1.84f03e93fef5p212, 0x1.26bb1bbb55508p7}, + {0x1.e62c4e38fdba1p215, 0x1.2b56082a42a4bp7}, + {0x1.2fdbb0e39f6b8p219, 0x1.2ff0f4992ffb6p7}, + {0x1.7bd29d1c875a2p222, 0x1.348be1081d50cp7}, + {0x1.dac74463a76e9p225, 0x1.3926cd770aa42p7}, + {0x1.28bc8abe48f57p229, 0x1.3dc1b9e5f7fap7}, + {0x1.72ebad6ddc67ep232, 0x1.425ca654e550ep7}, + {0x1.cfa698c952a3ap235, 0x1.46f792c3d2a53p7}, + {0x1.21c81f7dd42b1p239, 0x1.4b927f32bffb6p7}, + {0x1.6a3a275d4926bp242, 0x1.502d6ba1ad50ap7}, + {0x1.c4c8b134970ddp245, 0x1.54c858109aa0ep7}, + {0x1.61bcca711985dp252, 0x1.5dfe30ee75508p7}, + {0x1.ba2bfd0d5fe2ap255, 0x1.62991d5d62a5cp7}, + {0x1.59725db2728b7p262, 0x1.6bcef63b3d4fcp7}, + {0x1.afcef51f0fa33p265, 0x1.7069e2aa2aa5ap7}, + {0x1.0de1593368f8cp269, 0x1.7504cf1917f95p7}, + {0x1.5159af804425ep272, 0x1.799fbb88055p7}, + {0x1.a5b01b605409p275, 0x1.7e3aa7f6f2a3ep7}, + {0x1.078e111c34e5bp279, 0x1.82d59465dff9fp7}, + {0x1.497195634225fp282, 0x1.877080d4cd4f4p7}, + {0x1.9bcdfabc13053p285, 0x1.8c0b6d43baa4ep7}, + {0x1.0160bcb58c08cp289, 0x1.90a659b2a7fa7p7}, + {0x1.41b8ebe2eec13p292, 0x1.95414621954f4p7}, + {0x1.922726dbaa542p295, 0x1.99dc329082a46p7}, + {0x1.f6b0f09295714p298, 0x1.9e771eff6ffa3p7}, + {0x1.3a2e965b9d0b2p302, 0x1.a3120b6e5d4eep7}, + {0x1.88ba3bf284dd1p305, 0x1.a7acf7dd4aa4ep7}, + {0x1.32d17ed576f35p312, 0x1.b0e2d0bb254ep7}, + {0x1.7f85de8ad56bep315, 0x1.b57dbd2a12a44p7}, + {0x1.df67562d87c5cp318, 0x1.ba18a998fff65p7}, + {0x1.2ba095dc76db7p322, 0x1.beb39607ed4fp7}, + {0x1.7688bb5394bd3p325, 0x1.c34e8276daa48p7}, + {0x1.d42aea2878b45p328, 0x1.c7e96ee5c7f87p7}, + {0x1.249ad2594989p332, 0x1.cc845b54b54a6p7}, + }; + + for (double[] testCase: testCases) + failures+=testLog1pCase(testCase[0], testCase[1]); + + return failures; + } + + public static void main(String [] argv) { + int failures = 0; + + failures += testLog1p(); + + if (failures > 0) { + System.err.println("Testing log1p incurred " + + failures + " failures."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:13:04 2009 +++ new/test/java/lang/StrictMath/Tests.java Mon Jan 26 16:13:03 2009 @@ -0,0 +1,65 @@ +/* + * Copyright 2003 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. + */ + +/* + * + * + * Shared static test method for StrictMath tests. + */ + + +public class Tests { + private Tests(){} + + static int test(String testName, + double input, + double result, + double expected) { + if (Double.compare(expected, result ) != 0) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input + "\t(" + Double.toHexString(input) + ")\n" + + "\texpected " + expected + "\t(" + Double.toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + Double.toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + static int test(String testName, double input1, double input2, + double result, double expected) { + if (Double.compare(expected, result ) != 0) { + System.err.println("Failure for " + testName + ":\n" + + "\tFor input " + input1 + "\t(" + Double.toHexString(input1) + "), " + + + input2 + "\t(" + Double.toHexString(input2) + ")\n" + + "\texpected " + expected + "\t(" + Double.toHexString(expected) + ")\n" + + "\tgot " + result + "\t(" + Double.toHexString(result) + ")."); + return 1; + } + else + return 0; + } + + + +} --- /dev/null Mon Jan 26 16:13:06 2009 +++ new/test/java/lang/ToString.java Mon Jan 26 16:13:05 2009 @@ -0,0 +1,104 @@ +/* + * Copyright 2000 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 4031762 + * @summary Test the primitive wrappers static toString() + */ + +import java.util.Random; + +public class ToString { + + private static Random generator = new Random(); + + public static void main(String args[]) throws Exception { + // boolean wrapper + boolean b = false; + Boolean B = new Boolean(b); + if (!B.toString().equals(Boolean.toString(b))) + throw new RuntimeException("Boolean wrapper toString() failure."); + b = true; + B = new Boolean(b); + if (!B.toString().equals(Boolean.toString(b))) + throw new RuntimeException("Boolean wrapper toString() failure."); + + // char wrapper + for(int x=0; x<100; x++) { + char c = (char)generator.nextInt(); + Character C = new Character(c); + if (!C.toString().equals(Character.toString(c))) + throw new RuntimeException("Character wrapper toString() failure."); + } + + // byte wrapper + for(int x=0; x<100; x++) { + byte y = (byte)generator.nextInt(); + Byte Y = new Byte(y); + if (!Y.toString().equals(Byte.toString(y))) + throw new RuntimeException("Byte wrapper toString() failure."); + } + + // short wrapper + for(int x=0; x<100; x++) { + short s = (short)generator.nextInt(); + Short S = new Short(s); + if (!S.toString().equals(Short.toString(s))) + throw new RuntimeException("Short wrapper toString() failure."); + } + + // int wrapper + for(int x=0; x<100; x++) { + int i = generator.nextInt(); + Integer I = new Integer(i); + if (!I.toString().equals(Integer.toString(i))) + throw new RuntimeException("Integer wrapper toString() failure."); + } + + // long wrapper + for(int x=0; x<100; x++) { + long l = generator.nextLong(); + Long L = new Long(l); + if (!L.toString().equals(Long.toString(l))) + throw new RuntimeException("Long wrapper toString() failure."); + } + + // float wrapper + for(int x=0; x<100; x++) { + float f = generator.nextFloat(); + Float F = new Float(f); + if (!F.toString().equals(Float.toString(f))) + throw new RuntimeException("Float wrapper toString() failure."); + } + + // double wrapper + for(int x=0; x<100; x++) { + double d = generator.nextDouble(); + Double D = new Double(d); + if (!D.toString().equals(Double.toString(d))) + throw new RuntimeException("Double wrapper toString() failure."); + } + + } +} --- /dev/null Mon Jan 26 16:13:08 2009 +++ new/test/java/lang/annotation/AnnotationTypeMismatchException/FoundType.java Mon Jan 26 16:13:07 2009 @@ -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(); + } +} --- /dev/null Mon Jan 26 16:13:11 2009 +++ new/test/java/lang/annotation/Missing/A.java Mon Jan 26 16:13:10 2009 @@ -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 { +} --- /dev/null Mon Jan 26 16:13:13 2009 +++ new/test/java/lang/annotation/Missing/B.java Mon Jan 26 16:13:12 2009 @@ -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 { +} --- /dev/null Mon Jan 26 16:13:15 2009 +++ new/test/java/lang/annotation/Missing/C.java Mon Jan 26 16:13:14 2009 @@ -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; + } +} --- /dev/null Mon Jan 26 16:13:18 2009 +++ new/test/java/lang/annotation/Missing/D.java Mon Jan 26 16:13:17 2009 @@ -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; + } +} --- /dev/null Mon Jan 26 16:13:20 2009 +++ new/test/java/lang/annotation/Missing/Marker.java Mon Jan 26 16:13:19 2009 @@ -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 {} --- /dev/null Mon Jan 26 16:13:22 2009 +++ new/test/java/lang/annotation/Missing/Missing.java Mon Jan 26 16:13:21 2009 @@ -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 {} --- /dev/null Mon Jan 26 16:13:24 2009 +++ new/test/java/lang/annotation/Missing/MissingTest.java Mon Jan 26 16:13:23 2009 @@ -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); + } +} --- /dev/null Mon Jan 26 16:13:27 2009 +++ new/test/java/lang/annotation/Missing/MissingWrapper.java Mon Jan 26 16:13:26 2009 @@ -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(); +} --- /dev/null Mon Jan 26 16:13:29 2009 +++ new/test/java/lang/annotation/PackageMain.java Mon Jan 26 16:13:28 2009 @@ -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(); + } +} --- /dev/null Mon Jan 26 16:13:31 2009 +++ new/test/java/lang/annotation/RecursiveAnnotation.java Mon Jan 26 16:13:30 2009 @@ -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 { } --- /dev/null Mon Jan 26 16:13:33 2009 +++ new/test/java/lang/annotation/UnitTest.java Mon Jan 26 16:13:32 2009 @@ -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 void checkEquals(AnnotatedElement e1, AnnotatedElement e2, Class 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 void checkUnequals(AnnotatedElement e1, AnnotatedElement e2, Class 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 void checkSerialization(AnnotatedElement e, Class 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 Mon Jan 26 16:13:36 2009 +++ new/test/java/lang/annotation/loaderLeak/A.java Mon Jan 26 16:13:35 2009 @@ -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(); +} --- /dev/null Mon Jan 26 16:13:38 2009 +++ new/test/java/lang/annotation/loaderLeak/B.java Mon Jan 26 16:13:37 2009 @@ -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 {} --- /dev/null Mon Jan 26 16:13:40 2009 +++ new/test/java/lang/annotation/loaderLeak/C.java Mon Jan 26 16:13:39 2009 @@ -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 {} --- /dev/null Mon Jan 26 16:13:43 2009 +++ new/test/java/lang/annotation/loaderLeak/LoaderLeak.sh Mon Jan 26 16:13:42 2009 @@ -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 --- /dev/null Mon Jan 26 16:13:45 2009 +++ new/test/java/lang/annotation/loaderLeak/Main.java Mon Jan 26 16:13:44 2009 @@ -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> 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; + } +} --- /dev/null Mon Jan 26 16:13:47 2009 +++ new/test/java/lang/annotation/package-info.java Mon Jan 26 16:13:46 2009 @@ -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 {} --- /dev/null Mon Jan 26 16:13:50 2009 +++ new/test/java/math/BigDecimal/AddTests.java Mon Jan 26 16:13:49 2009 @@ -0,0 +1,280 @@ +/* + * Copyright 2006 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 6362557 + * @summary Some tests of add(BigDecimal, mc) + * @author Joseph D. Darcy + */ + +import java.math.*; +import static java.math.BigDecimal.*; +import java.util.Set; +import java.util.EnumSet; + +public class AddTests { + + private static Set nonExactRoundingModes = + EnumSet.complementOf(EnumSet.of(RoundingMode.UNNECESSARY)); + + /** + * Test for extreme value of scale and rounding precision that + * could cause integer overflow in right-shift-into-sticky-bit + * computations. + */ + private static int extremaTests() { + int failures = 0; + + failures += addWithoutException(valueOf(1, -Integer.MAX_VALUE), + valueOf(2, Integer.MAX_VALUE), null); + failures += addWithoutException(valueOf(1, -Integer.MAX_VALUE), + valueOf(-2, Integer.MAX_VALUE), null); + return failures; + } + + /** + * Print sum of b1 and b2; correct result will not throw an + * exception. + */ + private static int addWithoutException(BigDecimal b1, BigDecimal b2, MathContext mc) { + if (mc == null) + mc = new MathContext(2, RoundingMode.DOWN); + + try { + BigDecimal sum = b1.add(b2, mc); + printAddition(b1, b2, sum.toString()); + return 0; + } catch(ArithmeticException ae) { + printAddition(b1, b2, "Exception!"); + return 1; + } + } + + /** + * Test combinations of operands that may meet the condensation + * criteria when rounded to different precisions. + */ + private static int roundingGradationTests() { + int failures = 0; + + failures += roundAway(new BigDecimal("1234e100"), + new BigDecimal( "1234e97")); + + failures += roundAway(new BigDecimal("1234e100"), + new BigDecimal( "1234e96")); + + failures += roundAway(new BigDecimal("1234e100"), + new BigDecimal( "1234e95")); + + failures += roundAway(new BigDecimal("1234e100"), + new BigDecimal( "1234e94")); + + failures += roundAway(new BigDecimal("1234e100"), + new BigDecimal( "1234e93")); + + failures += roundAway(new BigDecimal("1234e100"), + new BigDecimal( "1234e92")); + + failures += roundAway(new BigDecimal("1234e100"), + new BigDecimal("1234e50")); + + + failures += roundAway(new BigDecimal("1000e100"), + new BigDecimal( "1234e97")); + + failures += roundAway(new BigDecimal("1000e100"), + new BigDecimal( "1234e96")); + + failures += roundAway(new BigDecimal("1000e100"), + new BigDecimal( "1234e95")); + + failures += roundAway(new BigDecimal("1000e100"), + new BigDecimal( "1234e94")); + + failures += roundAway(new BigDecimal("1000e100"), + new BigDecimal( "1234e93")); + + failures += roundAway(new BigDecimal("1000e100"), + new BigDecimal( "1234e92")); + + failures += roundAway(new BigDecimal("1000e100"), + new BigDecimal("1234e50")); + + + + failures += roundAway(new BigDecimal("1999e100"), + new BigDecimal( "1234e97")); + + failures += roundAway(new BigDecimal("1999e100"), + new BigDecimal( "1234e96")); + + failures += roundAway(new BigDecimal("1999e100"), + new BigDecimal( "1234e95")); + + failures += roundAway(new BigDecimal("1999e100"), + new BigDecimal( "1234e94")); + + failures += roundAway(new BigDecimal("1999e100"), + new BigDecimal( "1234e93")); + + failures += roundAway(new BigDecimal("1999e100"), + new BigDecimal( "1234e92")); + + failures += roundAway(new BigDecimal("1999e100"), + new BigDecimal("1234e50")); + + + + failures += roundAway(new BigDecimal("9999e100"), + new BigDecimal( "1234e97")); + + failures += roundAway(new BigDecimal("9999e100"), + new BigDecimal( "1234e96")); + + failures += roundAway(new BigDecimal("9999e100"), + new BigDecimal( "1234e95")); + + failures += roundAway(new BigDecimal("9999e100"), + new BigDecimal( "1234e94")); + + failures += roundAway(new BigDecimal("9999e100"), + new BigDecimal( "1234e93")); + + failures += roundAway(new BigDecimal("9999e100"), + new BigDecimal( "1234e92")); + + failures += roundAway(new BigDecimal("9999e100"), + new BigDecimal("1234e50")); + + return failures; + } + + private static void printAddition(BigDecimal b1, BigDecimal b2, String s) { + System.out.println("" + b1+ "\t+\t" + b2 + "\t=\t" + s); + } + + private static int roundAway(BigDecimal b1, BigDecimal b2) { + int failures = 0; + + b1.precision(); + b2.precision(); + + BigDecimal b1_negate = b1.negate(); + BigDecimal b2_negate = b2.negate(); + + b1_negate.precision(); + b2_negate.precision(); + + failures += roundAway1(b1, b2); + failures += roundAway1(b1, b2_negate); + failures += roundAway1(b1_negate, b2); + failures += roundAway1(b1_negate, b2_negate); + + return failures; + } + + private static int roundAway1(BigDecimal b1, BigDecimal b2) { + int failures = 0; + failures += roundAway0(b1, b2); + failures += roundAway0(b2, b1); + return failures; + } + + /** + * Compare b1.add(b2, mc) with b1.add(b2).round(mc) for a variety + * of MathContexts. + */ + private static int roundAway0(BigDecimal b1, BigDecimal b2) { + int failures = 0; + BigDecimal exactSum = b1.add(b2); + + for(int precision = 1 ; precision < exactSum.precision()+2; precision++) { + for(RoundingMode rm : nonExactRoundingModes) { + MathContext mc = new MathContext(precision, rm); + BigDecimal roundedExactSum = exactSum.round(mc); + + try { + BigDecimal sum = b1.add(b2, mc); + + if (!roundedExactSum.equals(sum) ) { + failures++; + System.out.println("Exact sum " + exactSum + + "\trounded by " + mc + + "\texpected: " + roundedExactSum + " got: "); + printAddition(b1, b2, sum.toString()); + } +// else { +// System.out.print(mc + "\t"); +// printAddition(b1, b2, sum.toString()); +// } + + } catch (ArithmeticException ae) { + printAddition(b1, b2, "Exception!"); + failures++; + } + } + } + + return failures; + } + + /** + * Verify calling the precision method should not change the + * computed result. + */ + private static int precisionConsistencyTest() { + int failures = 0; + MathContext mc = new MathContext(1,RoundingMode.DOWN); + BigDecimal a = BigDecimal.valueOf(1999, -1); //value is equivalent to 19990 + + BigDecimal sum1 = a.add(BigDecimal.ONE, mc); + a.precision(); + BigDecimal sum2 = a.add(BigDecimal.ONE, mc); + + if (!sum1.equals(sum2)) { + failures ++; + System.out.println("Unequal sums after calling precision!"); + System.out.print("Before:\t"); + printAddition(a, BigDecimal.ONE, sum1.toString()); + + System.out.print("After:\t"); + printAddition(a, BigDecimal.ONE, sum2.toString()); + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += extremaTests(); + failures += roundingGradationTests(); + failures += precisionConsistencyTest(); + + if (failures > 0) { + throw new RuntimeException("Incurred " + failures + + " failures while testing rounding add."); + } + } +} --- /dev/null Mon Jan 26 16:13:52 2009 +++ new/test/java/math/BigDecimal/CompareToTests.java Mon Jan 26 16:13:51 2009 @@ -0,0 +1,101 @@ +/* + * Copyright 2006 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 6473768 + * @summary Tests of BigDecimal.compareTo + * @author Joseph D. Darcy + */ +import java.math.*; +import static java.math.BigDecimal.*; + +public class CompareToTests { + private static int compareToTests() { + int failures = 0; + + final BigDecimal MINUS_ONE = BigDecimal.ONE.negate(); + + // First operand, second operand, expected compareTo result + BigDecimal [][] testCases = { + // Basics + {valueOf(0), valueOf(0), ZERO}, + {valueOf(0), valueOf(1), MINUS_ONE}, + {valueOf(1), valueOf(2), MINUS_ONE}, + {valueOf(2), valueOf(1), ONE}, + {valueOf(10), valueOf(10), ZERO}, + + // Significands would compare differently than scaled value + {valueOf(2,1), valueOf(2), MINUS_ONE}, + {valueOf(2,-1), valueOf(2), ONE}, + {valueOf(1,1), valueOf(2), MINUS_ONE}, + {valueOf(1,-1), valueOf(2), ONE}, + {valueOf(5,-1), valueOf(2), ONE}, + + // Boundary and near boundary values + {valueOf(Long.MAX_VALUE), valueOf(Long.MAX_VALUE), ZERO}, + {valueOf(Long.MAX_VALUE-1), valueOf(Long.MAX_VALUE), MINUS_ONE}, + {valueOf(Long.MIN_VALUE), valueOf(Long.MAX_VALUE), MINUS_ONE}, + {valueOf(Long.MIN_VALUE+1), valueOf(Long.MAX_VALUE), MINUS_ONE}, + {valueOf(Long.MIN_VALUE), valueOf(Long.MIN_VALUE), ZERO}, + {valueOf(Long.MIN_VALUE+1), valueOf(Long.MAX_VALUE), ONE}, + }; + + for (BigDecimal[] testCase : testCases) { + BigDecimal a = testCase[0]; + BigDecimal a_negate = a.negate(); + BigDecimal b = testCase[1]; + BigDecimal b_negate = b.negate(); + int expected = testCase[2].intValue(); + + failures += compareToTest(a, b, expected); + failures += compareToTest(a_negate, b, -1); + failures += compareToTest(a, b_negate, 1); + failures += compareToTest(a_negate, b_negate, -expected); + } + + + return failures; + } + + private static int compareToTest(BigDecimal a, BigDecimal b, int expected) { + int result = a.compareTo(b); + int failed = (result==expected) ? 0 : 1; + if (result == 1) { + System.err.println("(" + a + ").compareTo(" + b + ") => " + result + + "\n\tExpected " + expected); + } + return result; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += compareToTests(); + + if (failures > 0) { + throw new RuntimeException("Incurred " + failures + + " failures while testing exact compareTo."); + } + } +} --- /dev/null Mon Jan 26 16:13:54 2009 +++ new/test/java/math/BigDecimal/Constructor.java Mon Jan 26 16:13:53 2009 @@ -0,0 +1,42 @@ +/* + * Copyright 1999 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 4259453 + * @summary Test string constructor of BigDecimal + */ +import java.math.BigDecimal; + +public class Constructor { + public static void main(String[] args) throws Exception { + boolean nfe = false; + try { + BigDecimal bd = new BigDecimal("1.2e"); + } catch (NumberFormatException e) { + nfe = true; + } + if (!nfe) + throw new Exception("Didn't throw NumberFormatException"); + } +} --- /dev/null Mon Jan 26 16:13:57 2009 +++ new/test/java/math/BigDecimal/DivideTests.java Mon Jan 26 16:13:56 2009 @@ -0,0 +1,340 @@ +/* + * Copyright 2003-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 4851776 4907265 6177836 + * @summary Some tests for the divide methods. + * @author Joseph D. Darcy + * @compile -source 1.5 DivideTests.java + * @run main DivideTests + */ + +import java.math.*; +import static java.math.BigDecimal.*; + +public class DivideTests { + + // Preliminary exact divide method; could be used for comparison + // purposes. + BigDecimal anotherDivide(BigDecimal dividend, BigDecimal divisor) { + /* + * Handle zero cases first. + */ + if (divisor.signum() == 0) { // x/0 + if (dividend.signum() == 0) // 0/0 + throw new ArithmeticException("Division undefined"); // NaN + throw new ArithmeticException("Division by zero"); + } + if (dividend.signum() == 0) // 0/y + return BigDecimal.ZERO; + else { + /* + * Determine if there is a result with a terminating + * decimal expansion. Putting aside overflow and + * underflow considerations, the existance of an exact + * result only depends on the ratio of the intVal's of the + * dividend (i.e. this) and and divisor since the scales + * of the argument just affect where the decimal point + * lies. + * + * For the ratio of (a = this.intVal) and (b = + * divisor.intVal) to have a finite decimal expansion, + * once a/b is put in lowest terms, b must be equal to + * (2^i)*(5^j) for some integer i,j >= 0. Therefore, we + * first compute to see if b_prime =(b/gcd(a,b)) is equal + * to (2^i)*(5^j). + */ + BigInteger TWO = BigInteger.valueOf(2); + BigInteger FIVE = BigInteger.valueOf(5); + BigInteger TEN = BigInteger.valueOf(10); + + BigInteger divisorIntvalue = divisor.scaleByPowerOfTen(divisor.scale()).toBigInteger().abs(); + BigInteger dividendIntvalue = dividend.scaleByPowerOfTen(dividend.scale()).toBigInteger().abs(); + + BigInteger b_prime = divisorIntvalue.divide(dividendIntvalue.gcd(divisorIntvalue)); + + boolean goodDivisor = false; + int i=0, j=0; + + badDivisor: { + while(! b_prime.equals(BigInteger.ONE) ) { + int b_primeModTen = b_prime.mod(TEN).intValue() ; + + switch(b_primeModTen) { + case 0: + // b_prime divisible by 10=2*5, increment i and j + i++; + j++; + b_prime = b_prime.divide(TEN); + break; + + case 5: + // b_prime divisible by 5, increment j + j++; + b_prime = b_prime.divide(FIVE); + break; + + case 2: + case 4: + case 6: + case 8: + // b_prime divisible by 2, increment i + i++; + b_prime = b_prime.divide(TWO); + break; + + default: // hit something we shouldn't have + b_prime = BigInteger.ONE; // terminate loop + break badDivisor; + } + } + + goodDivisor = true; + } + + if( ! goodDivisor ) { + throw new ArithmeticException("Non terminating decimal expansion"); + } + else { + // What is a rule for determining how many digits are + // needed? Once that is determined, cons up a new + // MathContext object and pass it on to the divide(bd, + // mc) method; precision == ?, roundingMode is unnecessary. + + // Are we sure this is the right scale to use? Should + // also determine a precision-based method. + MathContext mc = new MathContext(dividend.precision() + + (int)Math.ceil( + 10.0*divisor.precision()/3.0), + RoundingMode.UNNECESSARY); + // Should do some more work here to rescale, etc. + return dividend.divide(divisor, mc); + } + } + } + + public static int powersOf2and5() { + int failures = 0; + + for(int i = 0; i < 6; i++) { + int powerOf2 = (int)StrictMath.pow(2.0, i); + + for(int j = 0; j < 6; j++) { + int powerOf5 = (int)StrictMath.pow(5.0, j); + int product; + + BigDecimal bd; + + try { + bd = BigDecimal.ONE.divide(new BigDecimal(product=powerOf2*powerOf5)); + } catch (ArithmeticException e) { + failures++; + System.err.println((new BigDecimal(powerOf2)).toString() + " / " + + (new BigDecimal(powerOf5)).toString() + " threw an exception."); + e.printStackTrace(); + } + + try { + bd = new BigDecimal(powerOf2).divide(new BigDecimal(powerOf5)); + } catch (ArithmeticException e) { + failures++; + System.err.println((new BigDecimal(powerOf2)).toString() + " / " + + (new BigDecimal(powerOf5)).toString() + " threw an exception."); + e.printStackTrace(); + } + + try { + bd = new BigDecimal(powerOf5).divide(new BigDecimal(powerOf2)); + } catch (ArithmeticException e) { + failures++; + System.err.println((new BigDecimal(powerOf5)).toString() + " / " + + (new BigDecimal(powerOf2)).toString() + " threw an exception."); + + e.printStackTrace(); + } + + } + } + return failures; + } + + public static int nonTerminating() { + int failures = 0; + int[] primes = {1, 3, 7, 13, 17}; + + // For each pair of prime products, verify the ratio of + // non-equal products has a non-terminating expansion. + + for(int i = 0; i < primes.length; i++) { + for(int j = i+1; j < primes.length; j++) { + + for(int m = 0; m < primes.length; m++) { + for(int n = m+1; n < primes.length; n++) { + int dividend = primes[i] * primes[j]; + int divisor = primes[m] * primes[n]; + + if ( ((dividend/divisor) * divisor) != dividend ) { + try { + BigDecimal quotient = (new BigDecimal(dividend). + divide(new BigDecimal(divisor))); + failures++; + System.err.println("Exact quotient " + quotient.toString() + + " returned for non-terminating fraction " + + dividend + " / " + divisor + "."); + } + catch (ArithmeticException e) { + ; // Correct result + } + } + + } + } + } + } + + return failures; + } + + public static int properScaleTests(){ + int failures = 0; + + BigDecimal[][] testCases = { + {new BigDecimal("1"), new BigDecimal("5"), new BigDecimal("2e-1")}, + {new BigDecimal("1"), new BigDecimal("50e-1"), new BigDecimal("2e-1")}, + {new BigDecimal("10e-1"), new BigDecimal("5"), new BigDecimal("2e-1")}, + {new BigDecimal("1"), new BigDecimal("500e-2"), new BigDecimal("2e-1")}, + {new BigDecimal("100e-2"), new BigDecimal("5"), new BigDecimal("20e-2")}, + {new BigDecimal("1"), new BigDecimal("32"), new BigDecimal("3125e-5")}, + {new BigDecimal("1"), new BigDecimal("64"), new BigDecimal("15625e-6")}, + {new BigDecimal("1.0000000"), new BigDecimal("64"), new BigDecimal("156250e-7")}, + }; + + + for(BigDecimal[] tc : testCases) { + BigDecimal quotient; + if (! (quotient = tc[0].divide(tc[1])).equals(tc[2]) ) { + failures++; + System.err.println("Unexpected quotient from " + tc[0] + " / " + tc[1] + + "; expected " + tc[2] + " got " + quotient); + } + } + + return failures; + } + + public static int trailingZeroTests() { + int failures = 0; + + MathContext mc = new MathContext(3, RoundingMode.FLOOR); + BigDecimal[][] testCases = { + {new BigDecimal("19"), new BigDecimal("100"), new BigDecimal("0.19")}, + {new BigDecimal("21"), new BigDecimal("110"), new BigDecimal("0.190")}, + }; + + for(BigDecimal[] tc : testCases) { + BigDecimal quotient; + if (! (quotient = tc[0].divide(tc[1], mc)).equals(tc[2]) ) { + failures++; + System.err.println("Unexpected quotient from " + tc[0] + " / " + tc[1] + + "; expected " + tc[2] + " got " + quotient); + } + } + + return failures; + } + + public static int scaledRoundedDivideTests() { + int failures = 0; + // Tests of the traditional scaled divide under different + // rounding modes. + + // Encode rounding mode and scale for the divide in a + // BigDecimal with the significand equal to the rounding mode + // and the scale equal to the number's scale. + + // {dividend, dividisor, rounding, quotient} + BigDecimal a = new BigDecimal("31415"); + BigDecimal a_minus = a.negate(); + BigDecimal b = new BigDecimal("10000"); + + BigDecimal c = new BigDecimal("31425"); + BigDecimal c_minus = c.negate(); + + BigDecimal[][] testCases = { + {a, b, BigDecimal.valueOf(ROUND_UP, 3), new BigDecimal("3.142")}, + {a_minus, b, BigDecimal.valueOf(ROUND_UP, 3), new BigDecimal("-3.142")}, + + {a, b, BigDecimal.valueOf(ROUND_DOWN, 3), new BigDecimal("3.141")}, + {a_minus, b, BigDecimal.valueOf(ROUND_DOWN, 3), new BigDecimal("-3.141")}, + + {a, b, BigDecimal.valueOf(ROUND_CEILING, 3), new BigDecimal("3.142")}, + {a_minus, b, BigDecimal.valueOf(ROUND_CEILING, 3), new BigDecimal("-3.141")}, + + {a, b, BigDecimal.valueOf(ROUND_FLOOR, 3), new BigDecimal("3.141")}, + {a_minus, b, BigDecimal.valueOf(ROUND_FLOOR, 3), new BigDecimal("-3.142")}, + + {a, b, BigDecimal.valueOf(ROUND_HALF_UP, 3), new BigDecimal("3.142")}, + {a_minus, b, BigDecimal.valueOf(ROUND_HALF_UP, 3), new BigDecimal("-3.142")}, + + {a, b, BigDecimal.valueOf(ROUND_DOWN, 3), new BigDecimal("3.141")}, + {a_minus, b, BigDecimal.valueOf(ROUND_DOWN, 3), new BigDecimal("-3.141")}, + + {a, b, BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("3.142")}, + {a_minus, b, BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("-3.142")}, + + {c, b, BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("3.142")}, + {c_minus, b, BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("-3.142")}, + }; + + for(BigDecimal tc[] : testCases) { + int scale = tc[2].scale(); + int rm = tc[2].unscaledValue().intValue(); + + BigDecimal quotient = tc[0].divide(tc[1], scale, rm); + if (!quotient.equals(tc[3])) { + failures++; + System.err.println("Unexpected quotient from " + tc[0] + " / " + tc[1] + + " scale " + scale + " rounding mode " + RoundingMode.valueOf(rm) + + "; expected " + tc[3] + " got " + quotient); + } + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += powersOf2and5(); + failures += nonTerminating(); + failures += properScaleTests(); + failures += trailingZeroTests(); + failures += scaledRoundedDivideTests(); + + if (failures > 0) { + throw new RuntimeException("Incurred " + failures + + " failures while testing exact divide."); + } + } +} --- /dev/null Mon Jan 26 16:13:59 2009 +++ new/test/java/math/BigDecimal/FloatDoubleValueTests.java Mon Jan 26 16:13:58 2009 @@ -0,0 +1,164 @@ +/* + * 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 6274390 + * @summary Verify {float, double}Value methods work with condensed representation + */ +import java.math.*; + +public class FloatDoubleValueTests { + private static final long two2the24 = 1L<<23; + private static final long two2the53 = 1L<<52; + + // Largest long that fits exactly in a float + private static final long maxFltLong = (long)(Integer.MAX_VALUE & ~(0xff)); + + // Largest long that fits exactly in a double + private static final long maxDblLong = Long.MAX_VALUE & ~(0x7ffL); + + static void testDoubleValue0(long i, BigDecimal bd) { + if (bd.doubleValue() != i || + bd.longValue() != i) + throw new RuntimeException("Unexpected equality failure for " + + i + "\t" + bd); + } + + static void testFloatValue0(long i, BigDecimal bd) { + if (bd.floatValue() != i || + bd.longValue() != i) + throw new RuntimeException("Unexpected equality failure for " + + i + "\t" + bd); + } + + static void checkFloat(BigDecimal bd, float f) { + float fbd = bd.floatValue(); + if (f != fbd ) { + String message = String.format("Bad conversion:"+ + "got %g (%a)\texpected %g (%a)", + f, f, fbd, fbd); + throw new RuntimeException(message); + } + } + + static void checkDouble(BigDecimal bd, double d) { + double dbd = bd.doubleValue(); + if (d != dbd ) { + String message = String.format("Bad conversion:"+ + "got %g (%a)\texpected %g (%a)", + d, d, dbd, dbd); + throw new RuntimeException(message); + } + } + + // Test integral values that will convert exactly to both float + // and double. + static void testFloatDoubleValue() { + long longValues[] = { + 0, + 1, + 2, + + two2the24-1, + two2the24, + two2the24+1, + + maxFltLong-1, + maxFltLong, + maxFltLong+1, + }; + + for(long i : longValues) { + BigDecimal bd1 = new BigDecimal(i); + BigDecimal bd2 = new BigDecimal(-i); + + testDoubleValue0( i, bd1); + testDoubleValue0(-i, bd2); + + testFloatValue0( i, bd1); + testFloatValue0(-i, bd2); + } + + } + + static void testDoubleValue() { + long longValues[] = { + Integer.MAX_VALUE-1, + Integer.MAX_VALUE, + (long)Integer.MAX_VALUE+1, + + two2the53-1, + two2the53, + two2the53+1, + + maxDblLong, + }; + + // Test integral values that will convert exactly to double + // but not float. + for(long i : longValues) { + BigDecimal bd1 = new BigDecimal(i); + BigDecimal bd2 = new BigDecimal(-i); + + testDoubleValue0( i, bd1); + testDoubleValue0(-i, bd2); + + checkFloat(bd1, (float)i); + checkFloat(bd2, -(float)i); + } + + // Now check values that should not convert the same in double + for(long i = maxDblLong; i < Long.MAX_VALUE; i++) { + BigDecimal bd1 = new BigDecimal(i); + BigDecimal bd2 = new BigDecimal(-i); + checkDouble(bd1, (double)i); + checkDouble(bd2, -(double)i); + + checkFloat(bd1, (float)i); + checkFloat(bd2, -(float)i); + } + + checkDouble(new BigDecimal(Long.MIN_VALUE), (double)Long.MIN_VALUE); + checkDouble(new BigDecimal(Long.MAX_VALUE), (double)Long.MAX_VALUE); + } + + static void testFloatValue() { + // Now check values that should not convert the same in float + for(long i = maxFltLong; i <= Integer.MAX_VALUE; i++) { + BigDecimal bd1 = new BigDecimal(i); + BigDecimal bd2 = new BigDecimal(-i); + checkFloat(bd1, (float)i); + checkFloat(bd2, -(float)i); + + testDoubleValue0( i, bd1); + testDoubleValue0(-i, bd2); + } + } + + public static void main(String[] args) throws Exception { + testFloatDoubleValue(); + testDoubleValue(); + testFloatValue(); + } +} --- /dev/null Mon Jan 26 16:14:01 2009 +++ new/test/java/math/BigDecimal/IntegralDivisionTests.java Mon Jan 26 16:14:00 2009 @@ -0,0 +1,352 @@ +/* + * Copyright 2003-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 4904082 4917089 6337226 + * @summary Tests that integral division and related methods return the proper result and scale. + * @author Joseph D. Darcy + * @compile -source 1.5 IntegralDivisionTests.java + * @run main IntegralDivisionTests + */ +import java.math.*; +public class IntegralDivisionTests { + + static int dividetoIntegralValueTests() { + int failures = 0; + + // Exact integer quotient should have the same results from + // the exact divide and dividetoIntegralValue + + + // Rounded results + BigDecimal [][] moreTestCases = { + {new BigDecimal("11003"), new BigDecimal("10"), new BigDecimal("1100")}, + {new BigDecimal("11003"), new BigDecimal("1e1"), new BigDecimal("1100.0")}, + {new BigDecimal("1e9"), new BigDecimal("1"), new BigDecimal("1e9")}, + {new BigDecimal("1e9"), new BigDecimal("1.00"), new BigDecimal("1e9")}, + {new BigDecimal("1e9"), new BigDecimal("0.1"), new BigDecimal("1e10")}, + {new BigDecimal("10e8"), new BigDecimal("0.1"), new BigDecimal("10e9")}, + {new BigDecimal("400e1"), new BigDecimal("5"), new BigDecimal("80e1")}, + {new BigDecimal("400e1"), new BigDecimal("4.999999999"), new BigDecimal("8e2")}, + {new BigDecimal("40e2"), new BigDecimal("5"), new BigDecimal("8e2")}, + }; + + for(BigDecimal [] testCase: moreTestCases) { + BigDecimal quotient; + if (! (quotient=testCase[0].divideToIntegralValue(testCase[1])).equals(testCase[2]) ){ + failures++; + // BigDecimal exact = testCase[0].divide(testCase[1]); + System.err.println(); + System.err.println("dividend = " + testCase[0] + " scale = " + testCase[0].scale()); + System.err.println("divisor = " + testCase[1] + " scale = " + testCase[1].scale()); + System.err.println("quotient = " + quotient + " scale = " + quotient.scale()); + System.err.println("expected = " + testCase[2] + " scale = " + testCase[2].scale()); + // System.err.println("exact = " + exact + " scale = " + exact.scale()); + } + } + + return failures; + } + + static int dividetoIntegralValueRoundedTests() { + int failures = 0; + + BigDecimal dividend = new BigDecimal("11003"); + BigDecimal divisor = new BigDecimal("10"); + BigDecimal [] quotients = { // Expected results with precision = + new BigDecimal("1100"), // 0 + null, // 1 + new BigDecimal("11e2"), // 2 + new BigDecimal("110e1"), // 3 + new BigDecimal("1100"), // 4 + }; + failures += divideContextTestPrecs(dividend, divisor, quotients); + + dividend = new BigDecimal("11003"); + divisor = new BigDecimal("1e1"); + BigDecimal [] quotients2 = { // Expected results with precision = + new BigDecimal("1100.0"), // 0 + null, // 1 + new BigDecimal("11e2"), // 2 + new BigDecimal("110e1"), // 3 + new BigDecimal("1100"), // 4 + new BigDecimal("1100.0"), // 5 + }; + failures += divideContextTestPrecs(dividend, divisor, quotients2); + + dividend = new BigDecimal("1230000"); + divisor = new BigDecimal("100"); + BigDecimal [] quotients3 = { // Expected results with precision = + new BigDecimal("12300"), // 0 + null, // 1 + null, // 2 + new BigDecimal("123e2"), // 3 + new BigDecimal("1230e1"), // 4 + new BigDecimal("12300"), // 5 + }; + failures += divideContextTestPrecs(dividend, divisor, quotients3); + + dividend = new BigDecimal("33"); + divisor = new BigDecimal("3"); + BigDecimal [] quotients4 = { // Expected results with precision = + new BigDecimal("11"), // 0 + null, // 1 + new BigDecimal("11"), // 2 + new BigDecimal("11"), // 3 + }; + failures += divideContextTestPrecs(dividend, divisor, quotients4); + + dividend = new BigDecimal("34"); + divisor = new BigDecimal("3"); + BigDecimal [] quotients5 = { // Expected results with precision = + new BigDecimal("11"), // 0 + null, // 1 + new BigDecimal("11"), // 2 + new BigDecimal("11"), // 3 + }; + failures += divideContextTestPrecs(dividend, divisor, quotients5); + + return failures; + } + + static int divideContextTestPrecs(BigDecimal dividend, + BigDecimal divisor, + BigDecimal[] quotients) + { + int failures = 0; + for(int i = 0; i < quotients.length; i++) { + BigDecimal result = null; + BigDecimal quotient = quotients[i]; + + try { + result = dividend.divideToIntegralValue(divisor, + new MathContext(i, RoundingMode.DOWN)); + } catch (ArithmeticException e) { + if (quotient != null) { + failures++; + System.err.println(); + System.err.println("Unexpected exception:"); + System.err.println("dividend = " + dividend + " scale = " + dividend.scale()); + System.err.println("divisor = " + divisor + " scale = " + divisor.scale()); + System.err.println("expected = " + quotient + " scale = " + quotient.scale()); + } + } + + if (quotient != null) { + if (! result.equals(quotient)) { + failures++; + System.err.println(); + System.err.println("Unexpected result:"); + System.err.println("dividend = " + dividend + " scale = " + dividend.scale()); + System.err.println("divisor = " + divisor + " scale = " + divisor.scale()); + System.err.println("quotient = " + result + " scale = " + result.scale()); + System.err.println("expected = " + quotient + " scale = " + quotient.scale()); + System.err.println("precision = " + i); + } + } else { + if (result != null) { + failures++; + System.err.println(); + System.err.println("Unexpected unexceptional result:"); + System.err.println("dividend = " + dividend + " scale = " + dividend.scale()); + System.err.println("divisor = " + divisor + " scale = " + divisor.scale()); + System.err.println("quotient = " + result + " scale = " + result.scale()); + System.err.println("precision = " + i); + } + } + + } + return failures; + } + + + static int divideContextTests(BigDecimal dividend, + BigDecimal divisor, + BigDecimal expected, + MathContext mc) { + int failures = 0; + + failures += divideContextTest(dividend, divisor, expected, mc); + failures += divideContextTest(dividend.negate(), divisor.negate(), expected, mc); + + if (expected != null) { + failures += divideContextTest(dividend.negate(), divisor, expected.negate(), mc); + failures += divideContextTest(dividend, divisor.negate(), expected.negate(), mc); + } + + return failures; + } + + + static int divideContextTest(BigDecimal dividend, + BigDecimal divisor, + BigDecimal expected, + MathContext mc) + { + int failures = 0; + + BigDecimal result = null; + + try { + result = dividend.divideToIntegralValue(divisor, mc); + } catch (ArithmeticException e) { + if (expected != null) { + failures++; + System.err.println(); + System.err.println("Unexpected exception:"); + System.err.println("dividend = " + dividend + " scale = " + dividend.scale()); + System.err.println("divisor = " + divisor + " scale = " + divisor.scale()); + System.err.println("expected = " + expected + " scale = " + expected.scale()); + System.err.println("MathContext = " + mc); + } + } + + if (expected != null) { + if (! result.equals(expected)) { + failures++; + System.err.println(); + System.err.println("Unexpected result:"); + System.err.println("dividend = " + dividend + " scale = " + dividend.scale()); + System.err.println("divisor = " + divisor + " scale = " + divisor.scale()); + System.err.println("expected = " + expected + " scale = " + expected.scale()); + System.err.println("result = " + result + " scale = " + result.scale()); + System.err.println("MathContext = " + mc); + } + } else { + if (result != null) { + failures++; + System.err.println(); + System.err.println("Unexpected unexceptional result:"); + System.err.println("dividend = " + dividend + " scale = " + dividend.scale()); + System.err.println("divisor = " + divisor + " scale = " + divisor.scale()); + System.err.println("quotient = " + result + " scale = " + result.scale()); + System.err.println("MathConext = " + mc); + } + } + + return failures; + } + + static int dividetoIntegralValueScalingTests() { + int failures = 0; + + BigDecimal dividend = new BigDecimal("123456789000"); + BigDecimal divisor = BigDecimal.ONE; + BigDecimal expected = new BigDecimal("123456789e3"); + MathContext mc = new MathContext(9,RoundingMode.DOWN); + failures += divideContextTests(dividend, divisor, expected, mc); + + + // 100/3 = 33 remainder 1 + int [] precisions = {0, 2, 3, 4}; + dividend = new BigDecimal(100); + divisor = new BigDecimal(3); + expected = new BigDecimal(33); + + for(RoundingMode rm: RoundingMode.values()) + for(int precision: precisions) { + failures += divideContextTests(dividend, divisor, expected, + new MathContext(precision, rm)); + } + + // 123000/10 = 12300 remainder 0 + dividend = new BigDecimal(123000); + divisor = new BigDecimal(10); + int[] precisions1 = {0, 1, 2, 3, 4, 5}; + BigDecimal[] expected1 = { + new BigDecimal("12300"), + null, + null, + new BigDecimal("123e2"), + new BigDecimal("1230e1"), + new BigDecimal("12300"), + }; + + for(RoundingMode rm: RoundingMode.values()) + for(int i = 0; i < precisions1.length; i++) { + failures += divideContextTests(dividend, divisor, + expected1[i], + new MathContext(precisions1[i], rm)); + } + + // 123e3/10 = 123e2 remainder 0 + dividend = new BigDecimal("123e3"); + divisor = new BigDecimal(10); + int[] precisions2 = {0, 1, 2, 3, 4, 5}; + BigDecimal[] expected2 = { + new BigDecimal("123e2"), + null, + null, + new BigDecimal("123e2"), + new BigDecimal("123e2"), + new BigDecimal("123e2"), + }; + + for(RoundingMode rm: RoundingMode.values()) + for(int i = 0; i < precisions2.length; i++) { + failures += divideContextTests(dividend, divisor, + expected2[i], + new MathContext(precisions2[i], rm)); + } + + + // 123000/1e1 = 12300.0 remainder 0 + dividend = new BigDecimal("123000"); + divisor = new BigDecimal("1e1"); + int[] precisions3 = {0, 1, 2, 3, 4, 5, 6}; + BigDecimal[] expected3 = { + new BigDecimal("12300.0"), + null, + null, + new BigDecimal("123e2"), + new BigDecimal("1230e1"), + new BigDecimal("12300"), + new BigDecimal("12300.0"), + }; + + for(RoundingMode rm: RoundingMode.values()) + for(int i = 0; i < precisions3.length; i++) { + failures += divideContextTests(dividend, divisor, + expected3[i], + new MathContext(precisions3[i], rm)); + } + + + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += dividetoIntegralValueTests(); + failures += dividetoIntegralValueRoundedTests(); + failures += dividetoIntegralValueScalingTests(); + + if (failures > 0) { + System.err.println("Encountered " + failures + + " failures while testing integral division."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:14:04 2009 +++ new/test/java/math/BigDecimal/NegateTests.java Mon Jan 26 16:14:03 2009 @@ -0,0 +1,111 @@ +/* + * 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 6325535 + * @summary Test for the rounding behavior of negate(MathContext) + * @author Joseph D. Darcy + */ + +import java.math.*; + +public class NegateTests { + + static BigDecimal negateThenRound(BigDecimal bd, MathContext mc) { + return bd.negate().plus(mc); + } + + + static BigDecimal absThenRound(BigDecimal bd, MathContext mc) { + return bd.abs().plus(mc); + } + + + static int negateTest(BigDecimal[][] testCases, MathContext mc) { + int failures = 0; + + for (BigDecimal [] testCase : testCases) { + + BigDecimal bd = testCase[0]; + BigDecimal neg1 = bd.negate(mc); + BigDecimal neg2 = negateThenRound(bd, mc); + BigDecimal expected = testCase[1]; + + if (! neg1.equals(expected) ) { + failures++; + System.err.println("(" + bd + ").negate(" + mc + ") => " + + neg1 + " != expected " + expected); + } + + if (! neg1.equals(neg2) ) { + failures++; + System.err.println("(" + bd + ").negate(" + mc + ") => " + + neg1 + " != ntr " + neg2); + } + + // Test abs consistency + BigDecimal abs = bd.abs(mc); + BigDecimal expectedAbs = absThenRound(bd,mc); + if (! abs.equals(expectedAbs) ) { + failures++; + System.err.println("(" + bd + ").abs(" + mc + ") => " + + abs + " != atr " + expectedAbs); + } + + } + + return failures; + } + + static int negateTests() { + int failures = 0; + BigDecimal [][] testCasesCeiling = { + {new BigDecimal("1.3"), new BigDecimal("-1")}, + {new BigDecimal("-1.3"), new BigDecimal("2")}, + }; + + failures += negateTest(testCasesCeiling, + new MathContext(1, RoundingMode.CEILING)); + + BigDecimal [][] testCasesFloor = { + {new BigDecimal("1.3"), new BigDecimal("-2")}, + {new BigDecimal("-1.3"), new BigDecimal("1")}, + }; + + failures += negateTest(testCasesFloor, + new MathContext(1, RoundingMode.FLOOR)); + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += negateTests(); + + if (failures > 0 ) + throw new RuntimeException("Incurred " + failures + " failures" + + " testing the negate and/or abs."); + } +} --- /dev/null Mon Jan 26 16:14:06 2009 +++ new/test/java/math/BigDecimal/PowTests.java Mon Jan 26 16:14:05 2009 @@ -0,0 +1,98 @@ +/* + * Copyright 2003 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 4916097 + * @summary Some exponent over/undeflow tests for the pow method + * @author Joseph D. Darcy + * @compile -source 1.5 PowTests.java + * @run main PowTests + */ + +import java.math.*; + +public class PowTests { + static int zeroAndOneTests() { + int failures = 0; + + BigDecimal[][] testCases = { + {BigDecimal.valueOf(0, Integer.MAX_VALUE), new BigDecimal(0), BigDecimal.valueOf(1, 0)}, + {BigDecimal.valueOf(0, Integer.MAX_VALUE), new BigDecimal(1), BigDecimal.valueOf(0, Integer.MAX_VALUE)}, + {BigDecimal.valueOf(0, Integer.MAX_VALUE), new BigDecimal(2), BigDecimal.valueOf(0, Integer.MAX_VALUE)}, + {BigDecimal.valueOf(0, Integer.MAX_VALUE), new BigDecimal(999999999), BigDecimal.valueOf(0, Integer.MAX_VALUE)}, + + {BigDecimal.valueOf(0, Integer.MIN_VALUE), new BigDecimal(0), BigDecimal.valueOf(1, 0)}, + {BigDecimal.valueOf(0, Integer.MIN_VALUE), new BigDecimal(1), BigDecimal.valueOf(0, Integer.MIN_VALUE)}, + {BigDecimal.valueOf(0, Integer.MIN_VALUE), new BigDecimal(2), BigDecimal.valueOf(0, Integer.MIN_VALUE)}, + {BigDecimal.valueOf(0, Integer.MIN_VALUE), new BigDecimal(999999999), BigDecimal.valueOf(0, Integer.MIN_VALUE)}, + + {BigDecimal.valueOf(1, Integer.MAX_VALUE), new BigDecimal(0), BigDecimal.valueOf(1, 0)}, + {BigDecimal.valueOf(1, Integer.MAX_VALUE), new BigDecimal(1), BigDecimal.valueOf(1, Integer.MAX_VALUE)}, + {BigDecimal.valueOf(1, Integer.MAX_VALUE), new BigDecimal(2), null}, // overflow + {BigDecimal.valueOf(1, Integer.MAX_VALUE), new BigDecimal(999999999), null}, // overflow + + {BigDecimal.valueOf(1, Integer.MIN_VALUE), new BigDecimal(0), BigDecimal.valueOf(1, 0)}, + {BigDecimal.valueOf(1, Integer.MIN_VALUE), new BigDecimal(1), BigDecimal.valueOf(1, Integer.MIN_VALUE)}, + {BigDecimal.valueOf(1, Integer.MIN_VALUE), new BigDecimal(2), null}, // underflow + {BigDecimal.valueOf(1, Integer.MIN_VALUE), new BigDecimal(999999999), null}, // underflow + }; + + for(BigDecimal[] testCase: testCases) { + int exponent = testCase[1].intValueExact(); + BigDecimal result; + + try{ + result = testCase[0].pow(exponent); + if (!result.equals(testCase[2]) ) { + failures++; + System.err.println("Unexpected result while raising " + + testCase[0] + + " to the " + exponent + " power; expected " + + testCase[2] + ", got " + result + "."); + } + } catch (ArithmeticException e) { + if (testCase[2] != null) { + failures++; + System.err.println("Unexpected exception while raising " + testCase[0] + + " to the " + exponent + " power."); + + } + } + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += zeroAndOneTests(); + + if (failures > 0) { + throw new RuntimeException("Incurred " + failures + + " failures while testing pow methods."); + } + } + +} --- /dev/null Mon Jan 26 16:14:09 2009 +++ new/test/java/math/BigDecimal/RoundingTests.java Mon Jan 26 16:14:08 2009 @@ -0,0 +1,59 @@ +/* + * 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 6334849 + * @summary Tests of dropping digits near the scale threshold + * @author Joseph D. Darcy + */ +import java.math.*; +public class RoundingTests { + private static int roundingTests() { + int failures = 0; + BigDecimal bd1 = BigDecimal.valueOf(11, Integer.MIN_VALUE); + BigDecimal bd2 = null; + MathContext mc = new MathContext(1); + try { + bd2 = bd1.round(mc); // should overflow here + failures++; + System.err.printf("Did not get expected overflow rounding %s to %d digits, got %s%n", + bd1, mc.getPrecision(), bd2); + } catch(ArithmeticException e) { + ; // expected + } + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += roundingTests(); + + if (failures > 0) { + System.err.println("Encountered " + failures + + " failures while testing rounding."); + throw new RuntimeException(); + } + } +} --- /dev/null Mon Jan 26 16:14:11 2009 +++ new/test/java/math/BigDecimal/ScaleByPowerOfTenTests.java Mon Jan 26 16:14:10 2009 @@ -0,0 +1,58 @@ +/* + * Copyright 2003 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 4899722 + * @summary Basic tests of scaleByPowerOfTen + * @author Joseph D. Darcy + */ + +import java.math.*; + +public class ScaleByPowerOfTenTests { + + public static void main(String argv[]) { + for (int i = -10; i < 10; i++) { + BigDecimal bd = BigDecimal.ONE.scaleByPowerOfTen(i); + BigDecimal expected; + + if (!bd.equals(expected = new BigDecimal(BigInteger.ONE, -i))) { + throw new RuntimeException("Unexpected result " + + bd.toString() + + "; expected " + + expected.toString()); + } + + bd = BigDecimal.ONE.negate().scaleByPowerOfTen(i); + if (!bd.equals(expected = new BigDecimal(BigInteger.ONE.negate(), -i))) { + throw new RuntimeException("Unexpected result " + + bd.toString() + + "; expected " + + expected.toString()); + } + + + } + } +} --- /dev/null Mon Jan 26 16:14:13 2009 +++ new/test/java/math/BigDecimal/SerializationTests.java Mon Jan 26 16:14:12 2009 @@ -0,0 +1,76 @@ +/* + * 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 6177836 + * @summary Verify BigDecimal objects with collapsed values are serialized properly. + * @author Joseph D. Darcy + */ + +import java.math.*; +import java.io.*; + +public class SerializationTests { + + static void checkSerialForm(BigDecimal bd) throws Exception { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(bos); + oos.writeObject(bd); + oos.flush(); + oos.close(); + ObjectInputStream ois = new + ObjectInputStream(new ByteArrayInputStream(bos.toByteArray())); + BigDecimal tmp = (BigDecimal)ois.readObject(); + + if (!bd.equals(tmp) || + bd.hashCode() != tmp.hashCode()) { + System.err.print(" original : " + bd); + System.err.println(" (hash: 0x" + Integer.toHexString(bd.hashCode()) + ")"); + System.err.print("serialized : " + tmp); + System.err.println(" (hash: 0x" + Integer.toHexString(tmp.hashCode()) + ")"); + throw new RuntimeException("Bad serial roundtrip"); + } + } + + public static void main(String[] args) throws Exception { + BigDecimal values[] = { + BigDecimal.ZERO, + BigDecimal.ONE, + BigDecimal.TEN, + new BigDecimal(0), + new BigDecimal(1), + new BigDecimal(10), + new BigDecimal(Integer.MAX_VALUE), + new BigDecimal(Long.MAX_VALUE-1), + new BigDecimal(BigInteger.valueOf(1), 1), + new BigDecimal(BigInteger.valueOf(100), 50), + }; + + for(BigDecimal value : values) { + checkSerialForm(value); + checkSerialForm(value.negate()); + } + + } +} --- /dev/null Mon Jan 26 16:14:16 2009 +++ new/test/java/math/BigDecimal/StringConstructor.java Mon Jan 26 16:14:15 2009 @@ -0,0 +1,163 @@ +/* + * Copyright 1999-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 4103117 4331084 4488017 4490929 6255285 6268365 + * @summary Tests the BigDecimal string constructor. + */ + +import java.math.*; +import java.util.Random; + +public class StringConstructor { + + private static int seed = new Random().nextInt(); + private static Random rnd = new Random(seed); + + public static void main(String[] args) throws Exception { + constructWithError(""); + constructWithError("+"); + constructWithError("-"); + constructWithError("+e"); + constructWithError("-e"); + constructWithError("e+"); + constructWithError("1.-0"); + constructWithError(".-123"); + constructWithError("-"); + constructWithError("--1.1"); + constructWithError("-+1.1"); + constructWithError("+-1.1"); + constructWithError("1-.1"); + constructWithError("1+.1"); + constructWithError("1.111+1"); + constructWithError("1.111-1"); + constructWithError("11.e+"); + constructWithError("11.e-"); + constructWithError("11.e+-"); + constructWithError("11.e-+"); + constructWithError("11.e-+1"); + constructWithError("11.e+-1"); + + // Range checks + constructWithError("1e"+Integer.MIN_VALUE); + constructWithError("10e"+Integer.MIN_VALUE); + constructWithError("0.01e"+Integer.MIN_VALUE); + constructWithError("1e"+((long)Integer.MIN_VALUE-1)); + constructWithError("1e"+((long)Integer.MAX_VALUE + 1)); + + leadingExponentZeroTest(); + nonAsciiZeroTest(); + + // Roundtrip tests + for (int i=0; i<100; i++) { + int size = rnd.nextInt(100) + 1; + BigInteger bi = new BigInteger(size, rnd); + if (rnd.nextBoolean()) + bi = bi.negate(); + int decimalLength = bi.toString().length(); + int scale = rnd.nextInt(decimalLength); + BigDecimal bd = new BigDecimal(bi, scale); + String bdString = bd.toString(); + // System.err.println("bi" + bi.toString() + "\tscale " + scale); + // System.err.println("bd string: " + bdString); + BigDecimal bdDoppel = new BigDecimal(bdString); + if (!bd.equals(bdDoppel)) { + System.err.println("Random number seed = " + seed); + System.err.println("bd string: scale: " + bd.scale() + + "\t" + bdString); + System.err.println("bd doppel: scale: " + bdDoppel.scale() + + "\t" + bdDoppel.toString()); + throw new RuntimeException("String constructor failure."); + } + } + } + + + /* + * Verify precision is set properly if the significand has + * non-ASCII leading zeros. + */ + private static void nonAsciiZeroTest() { + String values[] = { + "00004e5", + "\u0660\u0660\u0660\u06604e5", + }; + + BigDecimal expected = new BigDecimal("4e5"); + + for(String s : values) { + BigDecimal tmp = new BigDecimal(s); + // System.err.println("Testing " + s); + if (! expected.equals(tmp) || tmp.precision() != 1) { + System.err.println("Bad conversion of " + s + "got " + + tmp + "precision = " + tmp.precision()); + throw new RuntimeException("String constructor failure."); + } + } + + } + + private static void leadingExponentZeroTest() { + BigDecimal twelve = new BigDecimal("12"); + BigDecimal onePointTwo = new BigDecimal("1.2"); + + String start = "1.2e0"; + String end = "1"; + String middle = ""; + + // Test with more excess zeros than the largest number of + // decimal digits needed to represent a long + int limit = ((int)Math.log10(Long.MAX_VALUE)) + 6; + for(int i = 0; i < limit; i++, middle += "0") { + String t1 = start + middle; + String t2 = t1 + end; + + // System.out.println(i + "\t" + t1 + "\t" + t2); + testString(t1, onePointTwo); + testString(t2, twelve); + } + } + + private static void testString(String s, BigDecimal expected) { + testString0(s, expected); + testString0(switchZero(s), expected); + } + + private static void testString0(String s, BigDecimal expected) { + if (!expected.equals(new BigDecimal(s))) + throw new RuntimeException(s + " is not equal to " + expected); + } + + private static String switchZero(String s) { + return s.replace('0', '\u0660'); // Arabic-Indic zero + } + + private static void constructWithError(String badString) { + try { + BigDecimal d = new BigDecimal(badString); + throw new RuntimeException(badString + " accepted"); + } catch(NumberFormatException e) { + } + } +} --- /dev/null Mon Jan 26 16:14:18 2009 +++ new/test/java/math/BigDecimal/StrippingZerosTest.java Mon Jan 26 16:14:17 2009 @@ -0,0 +1,79 @@ +/* + * Copyright 2003 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 4108852 + * @summary A few tests of stripTrailingZeros + * @author Joseph D. Darcy + */ + +import java.math.*; + +public class StrippingZerosTest { + public static void main(String argv[]) { + BigDecimal [][] testCases = { + {new BigDecimal("1.00000"), new BigDecimal("1")}, + {new BigDecimal("1.000"), new BigDecimal("1")}, + {new BigDecimal("1"), new BigDecimal("1")}, + {new BigDecimal("0.1234"), new BigDecimal("0.1234")}, + {new BigDecimal("0.12340"), new BigDecimal("0.1234")}, + {new BigDecimal("0.12340000000"), new BigDecimal("0.1234")}, + {new BigDecimal("1234.5678"), new BigDecimal("1234.5678")}, + {new BigDecimal("1234.56780"), new BigDecimal("1234.5678")}, + {new BigDecimal("1234.567800000"), new BigDecimal("1234.5678")}, + {new BigDecimal("0"), new BigDecimal("0")}, + {new BigDecimal("0e100"), new BigDecimal("0e100")}, + {new BigDecimal("0e-100"), new BigDecimal("0e-100")}, + {new BigDecimal("10"), new BigDecimal("1e1")}, + {new BigDecimal("20"), new BigDecimal("2e1")}, + {new BigDecimal("100"), new BigDecimal("1e2")}, + {new BigDecimal("1000000000"), new BigDecimal("1e9")}, + {new BigDecimal("100000000e1"), new BigDecimal("1e9")}, + {new BigDecimal("10000000e2"), new BigDecimal("1e9")}, + {new BigDecimal("1000000e3"), new BigDecimal("1e9")}, + {new BigDecimal("100000e4"), new BigDecimal("1e9")}, + }; + + for(int i = 0; i < testCases.length; i++) { + + if (!(testCases[i][0]).stripTrailingZeros().equals(testCases[i][1])) { + throw new RuntimeException("For input " + testCases[i][0].toString() + + " did not received expected result " + + testCases[i][1].toString() + ", got " + + testCases[i][0].stripTrailingZeros()); + } + + testCases[i][0] = testCases[i][0].negate(); + testCases[i][1] = testCases[i][1].negate(); + + if (!(testCases[i][0]).stripTrailingZeros().equals(testCases[i][1])) { + throw new RuntimeException("For input " + testCases[i][0].toString() + + " did not received expected result " + + testCases[i][1].toString() + ", got " + + testCases[i][0].stripTrailingZeros()); + } + + } + } +} --- /dev/null Mon Jan 26 16:14:21 2009 +++ new/test/java/math/BigDecimal/ToPlainStringTests.java Mon Jan 26 16:14:20 2009 @@ -0,0 +1,90 @@ +/* + * 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 4984872 + * @summary Basic tests of toPlainString method + * @author Joseph D. Darcy + * @compile -source 1.5 ToPlainStringTests.java + * @run main ToPlainStringTests + */ + +import java.math.*; + +public class ToPlainStringTests { + public static void main(String argv[]) { + String [][] testCases = { + {"0", "0"}, + {"1", "1"}, + {"10", "10"}, + {"2e1", "20"}, + {"3e2", "300"}, + {"4e3", "4000"}, + {"5e4", "50000"}, + {"6e5", "600000"}, + {"7e6", "7000000"}, + {"8e7", "80000000"}, + {"9e8", "900000000"}, + {"1e9", "1000000000"}, + + {".0", "0.0"}, + {".1", "0.1"}, + {".10", "0.10"}, + {"1e-1", "0.1"}, + {"1e-1", "0.1"}, + {"2e-2", "0.02"}, + {"3e-3", "0.003"}, + {"4e-4", "0.0004"}, + {"5e-5", "0.00005"}, + {"6e-6", "0.000006"}, + {"7e-7", "0.0000007"}, + {"8e-8", "0.00000008"}, + {"9e-9", "0.000000009"}, + {"9000e-12", "0.000000009000"}, + }; + + int errors = 0; + for(String[] testCase: testCases) { + BigDecimal bd = new BigDecimal(testCase[0]); + String s; + + if (!(s=bd.toPlainString()).equals(testCase[1])) { + errors++; + System.err.println("Unexpected plain result ``" + + s + "'' from BigDecimal " + + bd); + } + + if (!(s=("-"+bd.toPlainString())).equals("-"+testCase[1])) { + errors++; + System.err.println("Unexpected plain result ``" + + s + "'' from BigDecimal " + + bd); + } + } + + if(errors > 0) + throw new RuntimeException(errors + " errors during run."); + } +} --- /dev/null Mon Jan 26 16:14:23 2009 +++ new/test/java/math/BigDecimal/ZeroScalingTests.java Mon Jan 26 16:14:22 2009 @@ -0,0 +1,466 @@ +/* + * Copyright 2003 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 4902952 4905407 4916149 + * @summary Tests that the scale of zero is propagated properly and has the proper effect. + * @author Joseph D. Darcy + * @compile -source 1.5 ZeroScalingTests.java + * @run main ZeroScalingTests + */ + +import java.math.*; +import java.util.*; + +public class ZeroScalingTests { + + static MathContext longEnough = new MathContext(50, RoundingMode.UNNECESSARY); + + static BigDecimal[] zeros = new BigDecimal[23]; + static { + for(int i = 0; i < 21; i++) { + zeros[i] = new BigDecimal(BigInteger.ZERO, i-10); + } + zeros[21] = new BigDecimal(BigInteger.ZERO, Integer.MIN_VALUE); + zeros[22] = new BigDecimal(BigInteger.ZERO, Integer.MAX_VALUE); + } + + static BigDecimal element = BigDecimal.valueOf(100, -2); + + static MathContext contexts[] = { + new MathContext(0, RoundingMode.UNNECESSARY), + new MathContext(100, RoundingMode.UNNECESSARY), + new MathContext(5, RoundingMode.UNNECESSARY), + new MathContext(4, RoundingMode.UNNECESSARY), + new MathContext(3, RoundingMode.UNNECESSARY), + new MathContext(2, RoundingMode.UNNECESSARY), + new MathContext(1, RoundingMode.UNNECESSARY), + }; + + + static int addTests() { + int failures = 0; + + for(BigDecimal zero1: zeros) { + for(BigDecimal zero2: zeros) { + BigDecimal expected = new BigDecimal(BigInteger.ZERO, + Math.max(zero1.scale(), zero2.scale())); + BigDecimal result; + + if(! (result=zero1.add(zero2)).equals(expected) ) { + failures++; + System.err.println("For classic exact add, expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero1.add(zero2, MathContext.UNLIMITED)).equals(expected) ) { + failures++; + System.err.println("For UNLIMITED math context add," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero1.add(zero2, longEnough)).equals(expected) ) { + failures++; + System.err.println("For longEnough math context add," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + } + } + + // Test effect of adding zero to a nonzero value. + for (MathContext mc: contexts) { + for (BigDecimal zero: zeros) { + if (Math.abs((long)zero.scale()) < 100 ) { + + int preferredScale = Math.max(zero.scale(), element.scale()); + if (mc.getPrecision() != 0) { + if (preferredScale < -4 ) + preferredScale = -4; + else if (preferredScale > -(5 - mc.getPrecision())) { + preferredScale = -(5 - mc.getPrecision()); + } + } + + + /* + System.err.println("\n " + element + " +\t" + zero + " =\t" + result); + + System.err.println("scales" + element.scale() + " \t" + zero.scale() + + " \t " + result.scale() + "\t precison = " + mc.getPrecision()); + System.err.println("expected scale = " + preferredScale); + */ + + BigDecimal result = element.add(zero, mc); + if (result.scale() != preferredScale || + result.compareTo(element) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + result = zero.add(element, mc); + if (result.scale() != preferredScale || + result.compareTo(element) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + result = element.negate().add(zero, mc); + if (result.scale() != preferredScale || + result.compareTo(element.negate()) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + result = zero.add(element.negate(), mc); + if (result.scale() != preferredScale || + result.compareTo(element.negate()) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + } + } + } + + return failures; + } + + static int subtractTests() { + int failures = 0; + + for(BigDecimal zero1: zeros) { + for(BigDecimal zero2: zeros) { + BigDecimal expected = new BigDecimal(BigInteger.ZERO, + Math.max(zero1.scale(), zero2.scale())); + BigDecimal result; + + if(! (result=zero1.subtract(zero2)).equals(expected) ) { + failures++; + System.err.println("For classic exact subtract, expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero1.subtract(zero2, MathContext.UNLIMITED)).equals(expected) ) { + failures++; + System.err.println("For UNLIMITED math context subtract," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero1.subtract(zero2, longEnough)).equals(expected) ) { + failures++; + System.err.println("For longEnough math context subtract," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + } + } + + + // Test effect of adding zero to a nonzero value. + for (MathContext mc: contexts) { + for (BigDecimal zero: zeros) { + if (Math.abs((long)zero.scale()) < 100 ) { + + int preferredScale = Math.max(zero.scale(), element.scale()); + if (mc.getPrecision() != 0) { + if (preferredScale < -4 ) + preferredScale = -4; + else if (preferredScale > -(5 - mc.getPrecision())) { + preferredScale = -(5 - mc.getPrecision()); + } + } + + + /* + System.err.println("\n " + element + " +\t" + zero + " =\t" + result); + + System.err.println("scales" + element.scale() + " \t" + zero.scale() + + " \t " + result.scale() + "\t precison = " + mc.getPrecision()); + System.err.println("expected scale = " + preferredScale); + */ + + BigDecimal result = element.subtract(zero, mc); + if (result.scale() != preferredScale || + result.compareTo(element) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + result = zero.subtract(element, mc); + if (result.scale() != preferredScale || + result.compareTo(element.negate()) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + result = element.negate().subtract(zero, mc); + if (result.scale() != preferredScale || + result.compareTo(element.negate()) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + result = zero.subtract(element.negate(), mc); + if (result.scale() != preferredScale || + result.compareTo(element) != 0) { + failures++; + System.err.println("Expected scale " + preferredScale + + " result scale was " + result.scale() + + " ; value was " + result); + } + + } + } + } + + return failures; + } + + static int multiplyTests() { + int failures = 0; + + BigDecimal ones[] = { + BigDecimal.valueOf(1, 0), + BigDecimal.valueOf(10, 1), + BigDecimal.valueOf(1000, 3), + BigDecimal.valueOf(100000000, 8), + }; + + List values = new LinkedList(); + values.addAll(Arrays.asList(zeros)); + values.addAll(Arrays.asList(ones)); + + for(BigDecimal zero1: zeros) { + for(BigDecimal value: values) { + BigDecimal expected = new BigDecimal(BigInteger.ZERO, + (int)Math.min(Math.max((long)zero1.scale()+value.scale(), + Integer.MIN_VALUE ), + Integer.MAX_VALUE ) ); + BigDecimal result; + + if(! (result=zero1.multiply(value)).equals(expected) ) { + failures++; + System.err.println("For classic exact multiply, expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero1.multiply(value, MathContext.UNLIMITED)).equals(expected) ) { + failures++; + System.err.println("For UNLIMITED math context multiply," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero1.multiply(value, longEnough)).equals(expected) ) { + failures++; + System.err.println("For longEnough math context multiply," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + } + } + + return failures; + } + + static int divideTests() { + int failures = 0; + + BigDecimal [] ones = { + BigDecimal.valueOf(1, 0), + BigDecimal.valueOf(10, -1), + BigDecimal.valueOf(100, -2), + BigDecimal.valueOf(1000, -3), + BigDecimal.valueOf(1000000, -5), + }; + + for(BigDecimal one: ones) { + for(BigDecimal zero: zeros) { + BigDecimal expected = new BigDecimal(BigInteger.ZERO, + (int)Math.min(Math.max((long)zero.scale() - one.scale(), + Integer.MIN_VALUE ), + Integer.MAX_VALUE ) ); + BigDecimal result; + + if(! (result=zero.divide(one)).equals(expected) ) { + failures++; + System.err.println("For classic exact divide, expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero.divide(one, MathContext.UNLIMITED)).equals(expected) ) { + failures++; + System.err.println("For UNLIMITED math context divide," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + if(! (result=zero.divide(one, longEnough)).equals(expected) ) { + failures++; + System.err.println("For longEnough math context divide," + + " expected scale of " + + expected.scale() + "; got " + + result.scale() + "."); + } + + } + } + + return failures; + } + + static int setScaleTests() { + int failures = 0; + + int scales[] = { + Integer.MIN_VALUE, + Integer.MIN_VALUE+1, + -10000000, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 10, + 10000000, + Integer.MAX_VALUE-1, + Integer.MAX_VALUE + }; + + for(BigDecimal zero: zeros) { + for(int scale: scales) { + try { + BigDecimal bd = zero.setScale(scale); + } + catch (ArithmeticException e) { + failures++; + System.err.println("Exception when trying to set a scale of " + scale + + " on " + zero); + } + } + } + + return failures; + } + + static int toEngineeringStringTests() { + int failures = 0; + + String [][] testCases = { + {"0E+10", "0.00E+12"}, + {"0E+9", "0E+9"}, + {"0E+8", "0.0E+9"}, + {"0E+7", "0.00E+9"}, + + {"0E-10", "0.0E-9"}, + {"0E-9", "0E-9"}, + {"0E-8", "0.00E-6"}, + {"0E-7", "0.0E-6"}, + }; + + for(String[] testCase: testCases) { + BigDecimal bd = new BigDecimal(testCase[0]); + String result = bd.toEngineeringString(); + + if (!result.equals(testCase[1]) || + !bd.equals(new BigDecimal(result))) { + failures++; + System.err.println("From input ``" + testCase[0] + ",'' " + + " bad engineering string output ``" + result + + "''; expected ``" + testCase[1] + ".''"); + } + + } + + return failures; + } + + static int ulpTests() { + int failures = 0; + + for(BigDecimal zero: zeros) { + BigDecimal result; + BigDecimal expected = BigDecimal.valueOf(1, zero.scale()); + + if (! (result=zero.ulp()).equals(expected) ) { + failures++; + System.err.println("Unexpected ulp value for zero value " + + zero + "; expected " + expected + + ", got " + result); + } + } + + return failures; + } + + public static void main(String argv[]) { + int failures = 0; + + failures += addTests(); + failures += subtractTests(); + failures += multiplyTests(); + failures += divideTests(); + failures += setScaleTests(); + failures += toEngineeringStringTests(); + failures += ulpTests(); + + if (failures > 0 ) { + throw new RuntimeException("Incurred " + failures + " failures" + + " testing the preservation of zero scales."); + } + } +} --- /dev/null Mon Jan 26 16:14:25 2009 +++ new/test/java/math/BigInteger/BigIntegerTest.java Mon Jan 26 16:14:24 2009 @@ -0,0 +1,792 @@ +/* + * Copyright 1998-2003 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 4181191 4161971 4227146 4194389 4823171 4624738 4812225 + * @summary tests methods in BigInteger + * @run main/timeout=400 BigIntegerTest + * @author madbot + */ + +import java.util.Random; +import java.math.BigInteger; +import java.io.*; + +/** + * This is a simple test class created to ensure that the results + * generated by BigInteger adhere to certain identities. Passing + * this test is a strong assurance that the BigInteger operations + * are working correctly. + * + * Three arguments may be specified which give the number of + * decimal digits you desire in the three batches of test numbers. + * + * The tests are performed on arrays of random numbers which are + * generated by a Random class as well as special cases which + * throw in boundary numbers such as 0, 1, maximum sized, etc. + * + */ +public class BigIntegerTest { + static Random rnd = new Random(); + static int size = 1000; // numbers per batch + static boolean failure = false; + + // Some variables for sizing test numbers in bits + private static int order1 = 100; + private static int order2 = 60; + private static int order3 = 30; + + public static void pow() { + int failCount1 = 0; + + for (int i=0; i>= 1; + } + + if (bigX.bitCount() != bitCount) { + //System.err.println(x+": "+bitCount+", "+bigX.bitCount()); + failCount++; + } + } + report("Bit Count", failCount); + } + + public static void bitLength() { + int failCount = 0; + + for (int i=0; i0) + order1 = (int)((Integer.parseInt(args[0]))* 3.333); + if (args.length >1) + order2 = (int)((Integer.parseInt(args[1]))* 3.333); + if (args.length >2) + order3 = (int)((Integer.parseInt(args[2]))* 3.333); + + prime(); + nextProbablePrime(); + + arithmetic(); + divideAndRemainder(); + pow(); + + bitCount(); + bitLength(); + bitOps(); + bitwise(); + + shift(); + + byteArrayConv(); + + modInv(); + modExp(); + modExp2(); + + stringConv(); + serialize(); + + if (failure) + throw new RuntimeException("Failure in BigIntegerTest."); + } + + /* + * Get a random or boundary-case number. This is designed to provide + * a lot of numbers that will find failure points, such as max sized + * numbers, empty BigIntegers, etc. + * + * If order is less than 2, order is changed to 2. + */ + private static BigInteger fetchNumber(int order) { + boolean negative = rnd.nextBoolean(); + int numType = rnd.nextInt(6); + BigInteger result = null; + if (order < 2) order = 2; + + switch (numType) { + case 0: // Empty + result = BigInteger.ZERO; + break; + + case 1: // One + result = BigInteger.ONE; + break; + + case 2: // All bits set in number + int numBytes = (order+7)/8; + byte[] fullBits = new byte[numBytes]; + for(int i=0; i 0) + failure = true; + } +} --- /dev/null Mon Jan 26 16:14:28 2009 +++ new/test/java/math/BigInteger/ModPow.java Mon Jan 26 16:14:27 2009 @@ -0,0 +1,52 @@ +/* + * Copyright 1998 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 4181191 + * @summary test BigInteger modPow method + */ +import java.math.BigInteger; +import java.util.Random; + +public class ModPow { + public static void main(String[] args) { + Random rnd = new Random(1234); + + for (int i=0; i<2000; i++) { + BigInteger m = new BigInteger(800, rnd); + BigInteger base = new BigInteger(16, rnd); + if (rnd.nextInt() % 1 == 0) + base = base.negate(); + BigInteger exp = new BigInteger(8, rnd); + + BigInteger z = base.modPow(exp, m); + BigInteger w = base.pow(exp.intValue()).mod(m); + if (!z.equals(w)){ + System.err.println(base +" ** " + exp + " mod "+ m); + System.err.println("modPow : " + z); + System.err.println("pow.mod: " + w); + throw new RuntimeException("BigInteger modPow failure."); + } + } + } +} --- /dev/null Mon Jan 26 16:14:30 2009 +++ new/test/java/math/BigInteger/ModPow65537.java Mon Jan 26 16:14:29 2009 @@ -0,0 +1,96 @@ +/* + * Copyright 2003 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 4891312 + * @summary verify that modPow() not broken by the special case for 65537 + * @author Andreas Sterbenz + */ + +import java.math.BigInteger; +import java.util.*; + +import java.security.*; +import java.security.spec.*; + +public class ModPow65537 { + + public static void main(String[] args) throws Exception { + // SunRsaSign uses BigInteger internally + KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "SunRsaSign"); + kpg.initialize(new RSAKeyGenParameterSpec(512, BigInteger.valueOf(65537))); + KeyPair kp = kpg.generateKeyPair(); + testSigning(kp); + + kpg.initialize(new RSAKeyGenParameterSpec(512, BigInteger.valueOf(65539))); + kp = kpg.generateKeyPair(); + testSigning(kp); + + kpg.initialize(new RSAKeyGenParameterSpec(512, BigInteger.valueOf(3))); + kp = kpg.generateKeyPair(); + testSigning(kp); + + // basic known answer test + BigInteger base = new BigInteger("19058071224156864789844466979330892664777520457048234786139035643344145635582"); + BigInteger mod = new BigInteger("75554098474976067521257305210610421240510163914613117319380559667371251381587"); + BigInteger exp1 = BigInteger.valueOf(65537); + BigInteger exp2 = BigInteger.valueOf(75537); + BigInteger exp3 = new BigInteger("13456870775607312149"); + + BigInteger res1 = new BigInteger("5770048609366563851320890693196148833634112303472168971638730461010114147506"); + BigInteger res2 = new BigInteger("63446979364051087123350579021875958137036620431381329472348116892915461751531"); + BigInteger res3 = new BigInteger("39016891919893878823999350081191675846357272199067075794096200770872982089502"); + + if (base.modPow(exp1, mod).equals(res1) == false) { + throw new Exception("Error using " + exp1); + } + if (base.modPow(exp2, mod).equals(res2) == false) { + throw new Exception("Error using " + exp2); + } + if (base.modPow(exp3, mod).equals(res3) == false) { + throw new Exception("Error using " + exp3); + } + + System.out.println("Passed"); + } + + private static void testSigning(KeyPair kp) throws Exception { + System.out.println(kp.getPublic()); + byte[] data = new byte[1024]; + new Random().nextBytes(data); + + Signature sig = Signature.getInstance("SHA1withRSA", "SunRsaSign"); + sig.initSign(kp.getPrivate()); + sig.update(data); + byte[] sigBytes = sig.sign(); + + sig.initVerify(kp.getPublic()); + sig.update(data); + if (sig.verify(sigBytes) == false) { + throw new Exception("signature verification failed"); + } + System.out.println("OK"); + } + +} --- /dev/null Mon Jan 26 16:14:32 2009 +++ new/test/java/math/BigInteger/ModPowPowersof2.java Mon Jan 26 16:14:31 2009 @@ -0,0 +1,85 @@ +/* + * Copyright 1998 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 4098742 + @summary Test biginteger modpow method + @author Michael McCloskey + @run main/othervm ModPowPowersof2 +*/ + +import java.math.BigInteger; +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.io.File; +import java.io.IOException; + +/** + * This class tests to see if using modPow on a power + * of two crashes the vm + * + */ +public class ModPowPowersof2 { + + public static void main(String args[]) throws Exception { + // Construct a command that runs the test in other vm + String[] command = new String[4]; + int n = 0; + + command[n++] = System.getProperty("java.home") + File.separator + + "bin" + File.separator + "java"; + if (System.getProperty("java.class.path") != null) { + command[n++] = "-classpath"; + command[n++] = System.getProperty("java.class.path"); + } + + command[n++] = "ModPowPowersof2$ModTester"; + + // Exec another vm to run test in + Process p = null; + p = Runtime.getRuntime().exec(command); + + // Read the result to determine if test failed + BufferedReader in = new BufferedReader(new InputStreamReader( + p.getInputStream())); + String s; + s = in.readLine(); + if (s == null) + throw new RuntimeException("ModPow causes vm crash"); + + } + + public static class ModTester { + public static void main(String [] args) { + BigInteger two = BigInteger.valueOf(2); + BigInteger four = BigInteger.valueOf(4); + + two.modPow(two, BigInteger.valueOf(4)); + two.modPow(two, BigInteger.valueOf(8)); + two.modPow(four, BigInteger.valueOf(8)); + + System.out.println("success"); + } + } + +} --- /dev/null Mon Jan 26 16:14:35 2009 +++ new/test/java/math/BigInteger/OperatorNpeTests.java Mon Jan 26 16:14:34 2009 @@ -0,0 +1,72 @@ +/* + * Copyright 2006 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 6365176 + * @summary Get NullPointerExceptions when expected + * @author Joseph D. Darcy + */ + +import java.math.*; +import static java.math.BigInteger.*; + +public class OperatorNpeTests { + + public static void main(String... argv) { + BigInteger[] specialValues = {ZERO, ONE, TEN}; + + for (BigInteger bd : specialValues) { + BigInteger result; + try { + result = bd.multiply(null); + throw new RuntimeException("Instead of NPE got " + result); + } catch (NullPointerException npe) { + ; // Expected + } + + try { + result = bd.divide(null); + throw new RuntimeException("Instead of NPE got " + result); + } catch (NullPointerException npe) { + ; // Expected + } + + try { + result = bd.add(null); + throw new RuntimeException("Instead of NPE got " + result); + } catch (NullPointerException npe) { + ; // Expected + } + + try { + result = bd.subtract(null); + throw new RuntimeException("Instead of NPE got " + result); + } catch (NullPointerException npe) { + ; // Expected + } + + + } + } +} --- /dev/null Mon Jan 26 16:14:37 2009 +++ new/test/java/math/BigInteger/ProbablePrime.java Mon Jan 26 16:14:36 2009 @@ -0,0 +1,48 @@ +/* + * Copyright 2002 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 4654323 + * @summary Tests functionality of isProbablePrime(Integer.MAX_VALUE) + */ +import java.math.*; + +public class ProbablePrime { + public static void main(String [] argv) { + BigInteger num = new BigInteger("4"); + int certainties[] = {-1, 0, 1, 2, 100, Integer.MAX_VALUE-1, + Integer.MAX_VALUE}; + boolean expectations[] = {true, true, false, false, false, + false, false}; + + for(int i = 0; i < certainties.length; i++) { + boolean b; + if((b=num.isProbablePrime(certainties[i])) != + expectations[i]) + throw new RuntimeException("Unexpected answer " + b + + " for certainty " + + certainties[i]); + } + } +} --- /dev/null Mon Jan 26 16:14:39 2009 +++ new/test/java/math/BigInteger/StringConstructor.java Mon Jan 26 16:14:38 2009 @@ -0,0 +1,90 @@ +/* + * Copyright 2001-2007 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 4489146 5017980 + * @summary tests String constructors of BigInteger + * @author Joseph D. Darcy + */ +import java.math.*; + +public class StringConstructor { + + + public static void main(String [] argv) { + // Good strings + constructWithoutError("0", 0L); + constructWithoutError("000000000000000000", 0L); + constructWithoutError("1", 1L); + constructWithoutError("-1", -1L); + constructWithoutError("+1", +1L); + constructWithoutError( "123456789123456789", 123456789123456789L); + constructWithoutError("+123456789123456789", 123456789123456789L); + constructWithoutError("-123456789123456789", -123456789123456789L); + constructWithoutError(Integer.toString(Integer.MIN_VALUE), + (long)Integer.MIN_VALUE); + constructWithoutError(Integer.toString(Integer.MAX_VALUE), + (long)Integer.MAX_VALUE); + constructWithoutError(Long.toString(Long.MIN_VALUE), + Long.MIN_VALUE); + constructWithoutError(Long.toString(Long.MAX_VALUE), + Long.MAX_VALUE); + + // Bad strings + constructWithError(""); + constructWithError("-"); + constructWithError("+"); + constructWithError("--"); + constructWithError("++"); + constructWithError("-000-0"); + constructWithError("+000+0"); + constructWithError("+000-0"); + constructWithError("--1234567890"); + constructWithError("++1234567890"); + constructWithError("-0-12345678"); + constructWithError("+0+12345678"); + constructWithError("--12345678-12345678-12345678"); + constructWithError("++12345678+12345678+12345678"); + constructWithError("12345-"); + constructWithError("12345+"); + } + + // this method adapted from ../BigDecimal/StringConstructor.java + private static void constructWithError(String badString) { + try { + BigInteger bi = new BigInteger(badString); + throw new RuntimeException(badString + " accepted"); + } catch(NumberFormatException e) { + } + } + + private static void constructWithoutError(String goodString, long value) { + BigInteger bi = new BigInteger(goodString); + if(bi.longValue() != value) { + System.err.printf("From ``%s'' expected %d, got %s.\n", goodString, value, bi); + throw new RuntimeException(); + } + } + +} --- /dev/null Mon Jan 26 16:14:42 2009 +++ new/test/java/math/BigInteger/UnicodeConstructor.java Mon Jan 26 16:14:41 2009 @@ -0,0 +1,57 @@ +/* + * Copyright 1998 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 4040456 + * @summary Test biginteger constructor with i18n string + */ + +import java.math.*; + +/** + * This class tests to see if creating a biginteger with an + * unicode japanese zero and one succeeds + * + */ +public class UnicodeConstructor { + + public static void main(String args[]) { + + try { + // the code for japanese zero + BigInteger b1 = new BigInteger("\uff10"); + System.err.println(b1.toString()); + + // Japanese 1010 + BigInteger b2 = new BigInteger("\uff11\uff10\uff11\uff10"); + System.err.println(b2.toString()); + } + catch (ArrayIndexOutOfBoundsException e) { + throw new RuntimeException( + "BigInteger is not accepting unicode initializers."); + } + + } + +} --- /dev/null Mon Jan 26 16:14:44 2009 +++ new/test/java/math/RoundingMode/RoundingModeTests.java Mon Jan 26 16:14:43 2009 @@ -0,0 +1,85 @@ +/* + * Copyright 2003 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 4851776 4891522 4905335 + * @summary Basic tests for the RoundingMode class. + * @author Joseph D. Darcy + * @compile -source 1.5 RoundingModeTests.java + * @run main RoundingModeTests + */ + +import java.math.RoundingMode; +import java.math.BigDecimal; + +public class RoundingModeTests { + public static void main(String [] argv) { + + // For each member of the family, make sure + // rm == valueOf(rm.toString()) + + for(RoundingMode rm: RoundingMode.values()) { + if (rm != RoundingMode.valueOf(rm.toString())) { + throw new RuntimeException("Bad roundtrip conversion of " + + rm.toString()); + } + } + + // Test that mapping of old integers to new values is correct + if (RoundingMode.valueOf(BigDecimal.ROUND_CEILING) != + RoundingMode.CEILING) { + throw new RuntimeException("Bad mapping for ROUND_CEILING"); + } + + if (RoundingMode.valueOf(BigDecimal.ROUND_DOWN) != + RoundingMode.DOWN) { + throw new RuntimeException("Bad mapping for ROUND_DOWN"); + } + + if (RoundingMode.valueOf(BigDecimal.ROUND_FLOOR) != + RoundingMode.FLOOR) { + throw new RuntimeException("Bad mapping for ROUND_FLOOR"); + } + + if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_DOWN) != + RoundingMode.HALF_DOWN) { + throw new RuntimeException("Bad mapping for ROUND_HALF_DOWN"); + } + + if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_EVEN) != + RoundingMode.HALF_EVEN) { + throw new RuntimeException("Bad mapping for ROUND_HALF_EVEN"); + } + + if (RoundingMode.valueOf(BigDecimal.ROUND_HALF_UP) != + RoundingMode.HALF_UP) { + throw new RuntimeException("Bad mapping for ROUND_HALF_UP"); + } + + if (RoundingMode.valueOf(BigDecimal.ROUND_UNNECESSARY) != + RoundingMode.UNNECESSARY) { + throw new RuntimeException("Bad mapping for ROUND_UNNECESARY"); + } + } +}