/*

 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * @test

 * @bug 4860891 4826732 4780454 4939441 4826652

 * @summary Tests for IEEE 754[R] recommended functions and similar methods

 * @author Joseph D. Darcy

 */

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 = Math.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(Math.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 = Math.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(Math.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.