/*

 * Copyright (c) 2013, 2015, 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

 * @ignore This test has huge memory requirements

 * @library /lib/testlibrary/

 * @build jdk.testlibrary.*

 * @run main/timeout=180/othervm -Xmx8g SymmetricRangeTests

 * @bug 6910473 8021204 8021203 9005933 8074460 8078672

 * @summary Test range of BigInteger values (use -Dseed=X to set PRNG seed)

 * @author Dmitry Nadezhin

 * @key randomness

 */

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.Arrays;

import java.math.BigInteger;

import java.util.Random;

public class SymmetricRangeTests {

    private static final BigInteger MAX_VALUE = makeMaxValue();

    private static final BigInteger MIN_VALUE = MAX_VALUE.negate();

    private static BigInteger makeMaxValue() {

        byte[] ba = new byte[1 << 28];

        Arrays.fill(ba, (byte) 0xFF);

        ba[0] = (byte) 0x7F;

        return new BigInteger(ba);

    }

    private static void check(String msg, BigInteger actual, BigInteger expected) {

        if (!actual.equals(expected)) {

            throw new RuntimeException(msg + ".bitLength()=" + actual.bitLength());

        }

    }

    private static void check(String msg, double actual, double expected) {

        if (actual != expected) {

            throw new RuntimeException(msg + "=" + actual);

        }

    }

    private static void check(String msg, float actual, float expected) {

        if (actual != expected) {

            throw new RuntimeException(msg + "=" + actual);

        }

    }

    private static void check(String msg, long actual, long expected) {

        if (actual != expected) {

            throw new RuntimeException(msg + "=" + actual);

        }

    }

    private static void check(String msg, int actual, int expected) {

        if (actual != expected) {

            throw new RuntimeException(msg + "=" + actual);

        }

    }

    private static void testOverflowInMakePositive() {

        System.out.println("Testing overflow in BigInteger.makePositive");

        byte[] ba = new byte[Integer.MAX_VALUE - 2];

        ba[0] = (byte) 0x80;

        try {

            BigInteger actual = new BigInteger(ba);

            throw new RuntimeException("new BigInteger(ba).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testBug8021204() {

        System.out.println("Testing Bug 8021204");

        StringBuilder sb = new StringBuilder();

        sb.append('1');

        for (int i = 0; i < (1 << 30) - 1; i++) {

            sb.append('0');

        }

        sb.append('1');

        String s = sb.toString();

        sb = null;

        try {

            BigInteger actual = new BigInteger(s, 16);

            throw new RuntimeException("new BigInteger(\"1000...001\").bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testOverflowInBitSieve() {

        System.out.println("Testing overflow in BitSieve.sieveSingle");

        int bitLength = (5 << 27) - 1;

        try {

            Random random = RandomFactory.getRandom();

            BigInteger actual = new BigInteger(bitLength, 0, random);

            throw new RuntimeException("new BigInteger(bitLength, 0, null).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

        try {

            BigInteger bi = BigInteger.ONE.shiftLeft(bitLength - 1).subtract(BigInteger.ONE);

            BigInteger actual = bi.nextProbablePrime();

            throw new RuntimeException("bi.nextActualPrime().bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testAdd() {

        System.out.println("Testing BigInteger.add");

        try {

            BigInteger actual = MAX_VALUE.add(BigInteger.ONE);

            throw new RuntimeException("BigInteger.MAX_VALUE.add(BigInteger.ONE).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testSubtract() {

        System.out.println("Testing BigInteger.subtract");

        try {

            BigInteger actual = MIN_VALUE.subtract(BigInteger.ONE);

            throw new RuntimeException("BigInteger.MIN_VALUE.subtract(BigInteger.ONE).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testMultiply() {

        System.out.println("Testing BigInteger.multiply");

        int py = 2000;

        int px = Integer.MAX_VALUE - py;

        BigInteger x = BigInteger.ONE.shiftLeft(px);

        BigInteger y = BigInteger.ONE.shiftLeft(py);

        try {

            BigInteger actual = x.multiply(y);

            throw new RuntimeException("(1 << " + px + " ) * (1 << " + py + ").bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testDivide() {

        System.out.println("Testing BigInteger.divide");

        check("BigInteger.MIN_VALUE.divide(BigInteger.valueOf(-1))",

                MIN_VALUE.divide(BigInteger.valueOf(-1)), MAX_VALUE);

        check("BigInteger.MIN_VALUE.divide(BigInteger.ONE)",

                MIN_VALUE.divide(BigInteger.ONE), MIN_VALUE);

    }

    private static void testDivideAndRemainder(String msg, BigInteger dividend, BigInteger divisor,

            BigInteger expectedQuotent, BigInteger expectedRemainder) {

        BigInteger[] qr = dividend.divideAndRemainder(divisor);

        check(msg + "[0]", qr[0], expectedQuotent);

        check(msg + "[1]", qr[1], expectedRemainder);

    }

    private static void testDivideAndRemainder() {

        System.out.println("Testing BigInteger.divideAndRemainder");

        testDivideAndRemainder("BigInteger.MIN_VALUE.divideAndRemainder(BigInteger.valueOf(-1))",

                MIN_VALUE, BigInteger.valueOf(-1),

                MAX_VALUE,

                BigInteger.ZERO);

    }

    private static void testBug9005933() {

        System.out.println("Testing Bug 9005933");

        int dividendPow = 2147483646;

        int divisorPow = 1568;

        BigInteger dividend = BigInteger.ONE.shiftLeft(dividendPow);

        BigInteger divisor = BigInteger.ONE.shiftLeft(divisorPow);

        testDivideAndRemainder("(1 << " + dividendPow + ").divideAndRemainder(1 << " + divisorPow + ")",

                dividend, divisor,

                BigInteger.ONE.shiftLeft(dividendPow - divisorPow),

                BigInteger.ZERO);

    }

    private static void testRemainder() {

        System.out.println("Testing BigInteger.remainder");

        check("BigInteger.MIN_VALUE.remainder(BigInteger.valueOf(-1))",

                MIN_VALUE.remainder(BigInteger.valueOf(-1)), BigInteger.ZERO);

    }

    private static void testPow() {

        System.out.println("Testing BigInteger.pow");

        check("BigInteger.MIN_VALUE.pow(1)",

                MIN_VALUE.pow(1), MIN_VALUE);

        try {

            BigInteger actual = BigInteger.valueOf(4).pow(Integer.MAX_VALUE);

            throw new RuntimeException("BigInteger.valueOf(4).pow(Integer.MAX_VALUE).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testGcd() {

        System.out.println("Testing BigInteger.gcd");

        check("BigInteger.MIN_VALUE.gcd(BigInteger.MIN_VALUE)",

                MIN_VALUE.gcd(MIN_VALUE), MAX_VALUE);

        check("BigInteger.MIN_VALUE.gcd(BigInteger.ZERO)",

                MIN_VALUE.gcd(BigInteger.ZERO), MAX_VALUE);

        check("BigInteger.ZERO.gcd(MIN_VALUE)",

                BigInteger.ZERO.gcd(MIN_VALUE), MAX_VALUE);

    }

    private static void testAbs() {

        System.out.println("Testing BigInteger.abs");

        check("BigInteger.MIN_VALUE.abs()",

                MIN_VALUE.abs(), MAX_VALUE);

        check("BigInteger.MAX_VALUE.abs()",

                MAX_VALUE.abs(), MAX_VALUE);

    }

    private static void testNegate() {

        System.out.println("Testing BigInteger.negate");

        check("BigInteger.MIN_VALUE.negate()",

                MIN_VALUE.negate(), MAX_VALUE);

        check("BigInteger.MAX_VALUE.negate()",

                MAX_VALUE.negate(), MIN_VALUE);

    }

    private static void testMod() {

        System.out.println("Testing BigInteger.mod");

        check("BigInteger.MIN_VALUE.mod(BigInteger.MAX_VALUE)",

                MIN_VALUE.mod(MAX_VALUE), BigInteger.ZERO);

        check("BigInteger.MAX_VALUE.mod(BigInteger.MAX_VALUE)",

                MIN_VALUE.mod(MAX_VALUE), BigInteger.ZERO);

    }

    private static void testModPow() {

        System.out.println("Testing BigInteger.modPow");

        BigInteger x = BigInteger.valueOf(3);

        BigInteger m = BigInteger.valueOf(-4).subtract(MIN_VALUE);

        check("BigInteger.valueOf(3).modPow(BigInteger.ONE, m)",

                x.modPow(BigInteger.ONE, m), x);

    }

    // slow test

    private static void testModInverse() {

        System.out.println("Testing BigInteger.modInverse");

        check("BigInteger.MIN_VALUE.modInverse(BigInteger.MAX_VALUE)",

                MIN_VALUE.modInverse(MAX_VALUE), MAX_VALUE.subtract(BigInteger.ONE));

    }

    private static void testShiftLeft() {

        System.out.println("Testing BigInteger.shiftLeft");

        try {

            BigInteger actual = MIN_VALUE.shiftLeft(1);

            throw new RuntimeException("BigInteger.MIN_VALUE.shiftLeft(1).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

        try {

            BigInteger actual = MAX_VALUE.shiftLeft(1);

            throw new RuntimeException("BigInteger.MAX_VALUE.shiftLeft(1).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testShiftRight() {

        System.out.println("Testing BigInteger.shiftRight");

        try {

            BigInteger actual = MIN_VALUE.shiftRight(-1);

            throw new RuntimeException("BigInteger.MIN_VALUE.shiftRight(-1).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

        try {

            BigInteger actual = MAX_VALUE.shiftRight(-1);

            throw new RuntimeException("BigInteger.MAX_VALUE.shiftRight(-1).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testAnd() {

        System.out.println("Testing BigInteger.and");

        check("BigInteger.MIN_VALUE.and(BigInteger.MIN_VALUE)",

                MIN_VALUE.and(MIN_VALUE), MIN_VALUE);

        check("BigInteger.MAX_VALUE.and(BigInteger.MAX_VALUE)",

                MAX_VALUE.and(MAX_VALUE), MAX_VALUE);

        check("BigInteger.MIN_VALUE.and(BigInteger.MAX_VALUE)",

                MIN_VALUE.and(MAX_VALUE), BigInteger.ONE);

        try {

            BigInteger actual = MIN_VALUE.and(BigInteger.valueOf(-2));

            throw new RuntimeException("BigInteger.MIN_VALUE.and(-2)).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testOr() {

        System.out.println("Testing BigInteger.or");

        check("BigInteger.MIN_VALUE.or(BigInteger.MIN_VALUE)",

                MIN_VALUE.or(MIN_VALUE), MIN_VALUE);

        check("BigInteger.MAX_VALUE.or(BigInteger.MAX_VALUE)",

                MAX_VALUE.or(MAX_VALUE), MAX_VALUE);

        check("BigInteger.MIN_VALUE.and(BigInteger.MAX_VALUE)",

                MIN_VALUE.or(MAX_VALUE), BigInteger.valueOf(-1));

    }

    private static void testXor() {

        System.out.println("Testing BigInteger.xor");

        check("BigInteger.MIN_VALUE.xor(BigInteger.MIN_VALUE)",

                MIN_VALUE.xor(MIN_VALUE), BigInteger.ZERO);

        check("BigInteger.MAX_VALUE.xor(BigInteger.MAX_VALUE)",

                MAX_VALUE.xor(MAX_VALUE), BigInteger.ZERO);

        check("BigInteger.MIN_VALUE.xor(BigInteger.MAX_VALUE)",

                MIN_VALUE.xor(MAX_VALUE), BigInteger.valueOf(-2));

        try {

            BigInteger actual = MIN_VALUE.xor(BigInteger.ONE);

            throw new RuntimeException("BigInteger.MIN_VALUE.xor(BigInteger.ONE)).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testNot() {

        System.out.println("Testing BigInteger.not");

        check("BigInteger.MIN_VALUE.not()",

                MIN_VALUE.not(), MAX_VALUE.subtract(BigInteger.ONE));

        try {

            BigInteger actual = MAX_VALUE.not();

            throw new RuntimeException("BigInteger.MAX_VALUE.not()).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testSetBit() {

        System.out.println("Testing BigInteger.setBit");

        check("BigInteger.MIN_VALUE.setBit(" + Integer.MAX_VALUE + ")",

                MIN_VALUE.setBit(Integer.MAX_VALUE), MIN_VALUE);

        try {

            BigInteger actual = MAX_VALUE.setBit(Integer.MAX_VALUE);

            throw new RuntimeException("BigInteger.MAX_VALUE.setBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testClearBit() {

        System.out.println("Testing BigInteger.clearBit");

        check("BigInteger.MAX_VALUE.clearBit(" + Integer.MAX_VALUE + ")",

                MAX_VALUE.clearBit(Integer.MAX_VALUE), MAX_VALUE);

        try {

            BigInteger actual = MIN_VALUE.clearBit(Integer.MAX_VALUE);

            throw new RuntimeException("BigInteger.MIN_VALUE.clearBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

        try {

            BigInteger actual = MIN_VALUE.clearBit(0);

            throw new RuntimeException("BigInteger.MIN_VALUE.clearBit(0).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testFlipBit() {

        System.out.println("Testing BigInteger.flipBit");

        try {

            BigInteger actual = MIN_VALUE.flipBit(Integer.MAX_VALUE);

            throw new RuntimeException("BigInteger.MIN_VALUE.flipBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

        try {

            BigInteger actual = MIN_VALUE.flipBit(0);

            throw new RuntimeException("BigInteger.MIN_VALUE.flipBit(0).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

        try {

            BigInteger actual = MAX_VALUE.flipBit(Integer.MAX_VALUE);

            throw new RuntimeException("BigInteger.MAX_VALUE.flipBit(" + Integer.MAX_VALUE + ").bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testGetLowestSetBit() {

        System.out.println("Testing BigInteger.getLowestSetBit");

        check("BigInteger.MIN_VALUE.getLowestSetBit()",

                MIN_VALUE.getLowestSetBit(), 0);

        check("BigInteger.MAX_VALUE.getLowestSetBit()",

                MAX_VALUE.getLowestSetBit(), 0);

    }

    private static void testBitLength() {

        System.out.println("Testing BigInteger.bitLength");

        check("BigInteger.MIN_NEXT.bitLength()",

                MIN_VALUE.bitLength(), Integer.MAX_VALUE);

        check("BigInteger.MAX_VALUE.bitLength()",

                MAX_VALUE.bitLength(), Integer.MAX_VALUE);

    }

    private static void testBitCount() {

        System.out.println("Testing BigInteger.bitCount");

        check("BigInteger.MIN_VALUE.bitCount()",

                MIN_VALUE.bitCount(), Integer.MAX_VALUE - 1);

        check("BigInteger.MAX_VALUE.bitCount()",

                MAX_VALUE.bitCount(), Integer.MAX_VALUE);

    }

    private static void testToString(String msg, int radix, BigInteger bi, int length, String startsWith, char c) {

        String s = bi.toString(radix);

        if (s.length() != length) {

            throw new RuntimeException(msg + ".length=" + s.length());

        }

        if (!s.startsWith(startsWith)) {

            throw new RuntimeException(msg + "[0]=" + s.substring(0, startsWith.length()));

        }

        for (int i = startsWith.length(); i < s.length(); i++) {

            if (s.charAt(i) != c) {

                throw new RuntimeException(msg + "[" + i + "]='" + s.charAt(i) + "'");

            }

        }

    }

    private static void testToString() {

        System.out.println("Testing BigInteger.toString");

        testToString("BigInteger.MIN_VALUE.toString(16)=", 16,

                BigInteger.valueOf(-1).shiftLeft(Integer.MAX_VALUE - 1),

                (1 << 29) + 1, "-4", '0');

    }

    private static void testToByteArrayWithConstructor(String msg, BigInteger bi, int length, byte msb, byte b, byte lsb) {

        byte[] ba = bi.toByteArray();

        if (ba.length != length) {

            throw new RuntimeException(msg + ".length=" + ba.length);

        }

        if (ba[0] != msb) {

            throw new RuntimeException(msg + "[0]=" + ba[0]);

        }

        for (int i = 1; i < ba.length - 1; i++) {

            if (ba[i] != b) {

                throw new RuntimeException(msg + "[" + i + "]=" + ba[i]);

            }

        }

        if (ba[ba.length - 1] != lsb) {

            throw new RuntimeException(msg + "[" + (ba.length - 1) + "]=" + ba[ba.length - 1]);

        }

        BigInteger actual = new BigInteger(ba);

        if (!actual.equals(bi)) {

            throw new RuntimeException(msg + ".bitLength()=" + actual.bitLength());

        }

    }

    private static void testToByteArrayWithConstructor() {

        System.out.println("Testing BigInteger.toByteArray with constructor");

        testToByteArrayWithConstructor("BigInteger.MIN_VALUE.toByteArray()",

                MIN_VALUE, (1 << 28), (byte) 0x80, (byte) 0x00, (byte) 0x01);

        testToByteArrayWithConstructor("BigInteger.MAX_VALUE.toByteArray()",

                MAX_VALUE, (1 << 28), (byte) 0x7f, (byte) 0xff, (byte) 0xff);

        byte[] ba = new byte[1 << 28];

        ba[0] = (byte) 0x80;

        try {

            BigInteger actual = new BigInteger(-1, ba);

            throw new RuntimeException("new BigInteger(-1, ba).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

        try {

            BigInteger actual = new BigInteger(1, ba);

            throw new RuntimeException("new BigInteger(1, ba).bitLength()=" + actual.bitLength());

        } catch (ArithmeticException e) {

            // expected

        }

    }

    private static void testIntValue() {

        System.out.println("Testing BigInteger.intValue");

        check("BigInteger.MIN_VALUE.intValue()",

                MIN_VALUE.intValue(), 1);

        check("BigInteger.MAX_VALUE.floatValue()",

                MAX_VALUE.intValue(), -1);

    }

    private static void testLongValue() {

        System.out.println("Testing BigInteger.longValue");

        check("BigInteger.MIN_VALUE.longValue()",

                MIN_VALUE.longValue(), 1L);

        check("BigInteger.MAX_VALUE.longValue()",

                MAX_VALUE.longValue(), -1L);

    }

    private static void testFloatValue() {

        System.out.println("Testing BigInteger.floatValue, Bug 8021203");

        check("BigInteger.MIN_VALUE_.floatValue()",

                MIN_VALUE.floatValue(), Float.NEGATIVE_INFINITY);

        check("BigInteger.MAX_VALUE.floatValue()",

                MAX_VALUE.floatValue(), Float.POSITIVE_INFINITY);

    }

    private static void testDoubleValue() {

        System.out.println("Testing BigInteger.doubleValue, Bug 8021203");

        check("BigInteger.MIN_VALUE.doubleValue()",