/*
 * Copyright (c) 2024, 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.
 */

import jdk.test.lib.RandomFactory;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.Arguments;

import java.math.BigInteger;
import java.math.MutableBigIntegerBox;
import java.util.Arrays;
import java.util.Random;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static java.math.MutableBigIntegerBox.*;

/**
 * @test
 * @bug 8336274
 * @summary Tests for correctness of MutableBigInteger.leftShift(int)
 * @library /test/lib
 * @build jdk.test.lib.RandomFactory
 * @build java.base/java.math.MutableBigIntegerBox
 * @key randomness
 * @run junit MutableBigIntegerShiftTests
 */
public class MutableBigIntegerShiftTests {

    private static final int ORDER_SMALL = 60;
    private static final int ORDER_MEDIUM = 100;

    private static final Random random = RandomFactory.getRandom();

    private static int[] orders() {
        return new int[] { ORDER_SMALL, ORDER_MEDIUM };
    }

    @ParameterizedTest
    @MethodSource("orders")
    public void shift(int order) {
        for (int i = 0; i < 100; i++) {
            test(fetchNumber(order), random.nextInt(200));
        }
    }

    @ParameterizedTest
    @MethodSource("pathTargetedCases")
    public void test(MutableBigIntegerBox x, int n) {
        leftShiftAssertions(x, n);
    }

    private static Arguments[] pathTargetedCases() {
        return new Arguments[] {
                // intLen == 0
                Arguments.of(MutableBigIntegerBox.ZERO,
                        random.nextInt(33)),
                // intLen != 0 && n <= leadingZeros
                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
                        random.nextInt(1, 17)),
                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits == 0
                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32) }),
                        32),
                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits != 0
                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
                        32 + random.nextInt(1, 17)),
                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
                // && newOffset != offset
                Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 32) }, 1, 1),
                        32),
                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
                // && newOffset == offset
                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32), random.nextInt() }, 0, 1),
                        32),
                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
                // && newOffset != offset
                Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 16) }, 1, 1),
                        32 + random.nextInt(1, 17)),
                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
                // && newOffset == offset
                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16), random.nextInt() }, 0, 1),
                        32 + random.nextInt(1, 17)),
                // intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length < newLen
                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32) }),
                        random.nextInt(17, 32)),
                // intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset != offset
                Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L << 15, 1L << 32) }, 1, 1),
                        random.nextInt(17, 32)),
                // intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset == offset
                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32), random.nextInt() }, 0, 1),
                        random.nextInt(17, 32)),
        };
    }

    private static void leftShiftAssertions(MutableBigIntegerBox x, int n) {
        MutableBigIntegerBox xShifted = x.shiftLeft(n);
        assertEquals(x.multiply(new MutableBigIntegerBox(BigInteger.TWO.pow(n))), xShifted);
        assertEquals(x, xShifted.shiftRight(n));
    }

    /*
     * 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 MutableBigIntegers, etc.
     *
     * If order is less than 2, order is changed to 2.
     */
    private static MutableBigIntegerBox fetchNumber(int order) {
        int numType = random.nextInt(8);
        MutableBigIntegerBox result = null;
        if (order < 2) order = 2;

        int[] val;
        switch (numType) {
            case 0: // Empty
                result = MutableBigIntegerBox.ZERO;
                break;

            case 1: // One
                result = MutableBigIntegerBox.ONE;
                break;

            case 2: // All bits set in number
                int numInts = (order + 31) >> 5;
                int[] fullBits = new int[numInts];
                Arrays.fill(fullBits, -1);

                fullBits[0] &= -1 >>> -order;
                result = new MutableBigIntegerBox(fullBits);
                break;

            case 3: // One bit in number
                result = MutableBigIntegerBox.ONE.shiftLeft(random.nextInt(order));
                break;

            case 4: // Random bit density
                val = new int[(order + 31) >> 5];
                int iterations = random.nextInt(order);
                for (int i = 0; i < iterations; i++) {
                    int bitIdx = random.nextInt(order);
                    val[bitIdx >> 5] |= 1 << bitIdx;
                }
                result = new MutableBigIntegerBox(val);
                break;
            case 5: // Runs of consecutive ones and zeros
                result = ZERO;
                int remaining = order;
                int bit = random.nextInt(2);
                while (remaining > 0) {
                    int runLength = Math.min(remaining, random.nextInt(order));
                    result = result.shiftLeft(runLength);
                    if (bit > 0)
                        result = result.add(ONE.shiftLeft(runLength).subtract(ONE));
                    remaining -= runLength;
                    bit = 1 - bit;
                }
                break;
            case 6: // random bits with trailing space
                int len = random.nextInt((order + 31) >> 5) + 1;
                int offset = random.nextInt(len);
                val = new int[len << 1];
                for (int i = 0; i < val.length; i++)
                    val[i] = random.nextInt();
                result = new MutableBigIntegerBox(val, offset, len);
                break;
            default: // random bits
                result = new MutableBigIntegerBox(new BigInteger(order, random));
        }

        return result;
    }
}