/*
 * Copyright (c) 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

// This file is available under and governed by the GNU General Public
// License version 2 only, as published by the Free Software Foundation.
// However, the following notice accompanied the original version of this
// file:
//
// Copyright 2012 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package jdk.nashorn.internal.runtime.doubleconv.test;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import jdk.nashorn.internal.runtime.doubleconv.DoubleConversion;
import jdk.nashorn.internal.runtime.doubleconv.DtoaBuffer;
import jdk.nashorn.internal.runtime.doubleconv.DtoaMode;

import org.testng.annotations.Test;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;

/**
 * FastDtoa tests
 *
 * @test
 * @run testng jdk.nashorn.internal.runtime.doubleconv.test.FastDtoaTest
 */
@SuppressWarnings("javadoc")
public class BignumDtoaTest {

    final static private int BUFFER_SIZE = 100;

    // Removes trailing '0' digits.
    // Can return the empty string if all digits are 0.
    private static String trimRepresentation(final String representation) {
        final int len = representation.length();
        int i;
        for (i = len - 1; i >= 0; --i) {
            if (representation.charAt(i) != '0') break;
        }
        return representation.substring(0, i + 1);
    }

    @Test
    public void testBignumVarious() {
        final DtoaBuffer buffer = new DtoaBuffer(BUFFER_SIZE);

        DoubleConversion.bignumDtoa(1, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("1", buffer.getRawDigits());
        assertEquals(1, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(1.0, DtoaMode.FIXED, 3, buffer);
        assertTrue(3 >= buffer.getLength() - buffer.getDecimalPoint());
        assertEquals("1", trimRepresentation(buffer.getRawDigits()));
        assertEquals(1, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(1.0, DtoaMode.PRECISION, 3, buffer);
        assertTrue(3 >= buffer.getLength());
        assertEquals("1", trimRepresentation(buffer.getRawDigits()));
        assertEquals(1, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(1.5, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("15", buffer.getRawDigits());
        assertEquals(1, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(1.5, DtoaMode.FIXED, 10, buffer);
        assertTrue(10 >= buffer.getLength() - buffer.getDecimalPoint());
        assertEquals("15", trimRepresentation(buffer.getRawDigits()));
        assertEquals(1, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(1.5, DtoaMode.PRECISION, 10, buffer);
        assertTrue(10 >= buffer.getLength());
        assertEquals("15", trimRepresentation(buffer.getRawDigits()));
        assertEquals(1, buffer.getDecimalPoint());
        buffer.reset();

        final double min_double = 5e-324;
        DoubleConversion.bignumDtoa(min_double, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("5", buffer.getRawDigits());
        assertEquals(-323, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(min_double, DtoaMode.FIXED, 5, buffer);
        assertTrue(5 >= buffer.getLength() - buffer.getDecimalPoint());
        assertEquals("", trimRepresentation(buffer.getRawDigits()));
        buffer.reset();

        DoubleConversion.bignumDtoa(min_double, DtoaMode.PRECISION, 5, buffer);
        assertTrue(5 >= buffer.getLength());
        assertEquals("49407", trimRepresentation(buffer.getRawDigits()));
        assertEquals(-323, buffer.getDecimalPoint());
        buffer.reset();

        final double max_double = 1.7976931348623157e308;
        DoubleConversion.bignumDtoa(max_double, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("17976931348623157", buffer.getRawDigits());
        assertEquals(309, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(max_double, DtoaMode.PRECISION, 7, buffer);
        assertTrue(7 >= buffer.getLength());
        assertEquals("1797693", trimRepresentation(buffer.getRawDigits()));
        assertEquals(309, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(4294967272.0, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("4294967272", buffer.getRawDigits());
        assertEquals(10, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(4294967272.0, DtoaMode.FIXED, 5, buffer);
        assertEquals("429496727200000", buffer.getRawDigits());
        assertEquals(10, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(4294967272.0, DtoaMode.PRECISION, 14, buffer);
        assertTrue(14 >= buffer.getLength());
        assertEquals("4294967272", trimRepresentation(buffer.getRawDigits()));
        assertEquals(10, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(4.1855804968213567e298, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("4185580496821357", buffer.getRawDigits());
        assertEquals(299, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(4.1855804968213567e298, DtoaMode.PRECISION, 20, buffer);
        assertTrue(20 >= buffer.getLength());
        assertEquals("41855804968213567225", trimRepresentation(buffer.getRawDigits()));
        assertEquals(299, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(5.5626846462680035e-309, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("5562684646268003", buffer.getRawDigits());
        assertEquals(-308, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(5.5626846462680035e-309, DtoaMode.PRECISION, 1, buffer);
        assertTrue(1 >= buffer.getLength());
        assertEquals("6", trimRepresentation(buffer.getRawDigits()));
        assertEquals(-308, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(2147483648.0, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("2147483648", buffer.getRawDigits());
        assertEquals(10, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(2147483648.0, DtoaMode.FIXED, 2, buffer);
        assertTrue(2 >= buffer.getLength() - buffer.getDecimalPoint());
        assertEquals("2147483648", trimRepresentation(buffer.getRawDigits()));
        assertEquals(10, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(2147483648.0, DtoaMode.PRECISION, 5, buffer);
        assertTrue(5 >= buffer.getLength());
        assertEquals("21475", trimRepresentation(buffer.getRawDigits()));
        assertEquals(10, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(3.5844466002796428e+298, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("35844466002796428", buffer.getRawDigits());
        assertEquals(299, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(3.5844466002796428e+298, DtoaMode.PRECISION, 10, buffer);
        assertTrue(10 >= buffer.getLength());
        assertEquals("35844466", trimRepresentation(buffer.getRawDigits()));
        assertEquals(299, buffer.getDecimalPoint());
        buffer.reset();

        final long smallest_normal64 = 0x0010000000000000L;
        double v = Double.longBitsToDouble(smallest_normal64);
        DoubleConversion.bignumDtoa(v, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("22250738585072014", buffer.getRawDigits());
        assertEquals(-307, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(v, DtoaMode.PRECISION, 20, buffer);
        assertTrue(20 >= buffer.getLength());
        assertEquals("22250738585072013831", trimRepresentation(buffer.getRawDigits()));
        assertEquals(-307, buffer.getDecimalPoint());
        buffer.reset();

        final long largest_denormal64 = 0x000FFFFFFFFFFFFFL;
        v = Double.longBitsToDouble(largest_denormal64);
        DoubleConversion.bignumDtoa(v, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("2225073858507201", buffer.getRawDigits());
        assertEquals(-307, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(v, DtoaMode.PRECISION, 20, buffer);
        assertTrue(20 >= buffer.getLength());
        assertEquals("2225073858507200889", trimRepresentation(buffer.getRawDigits()));
        assertEquals(-307, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(4128420500802942e-24, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("4128420500802942", buffer.getRawDigits());
        assertEquals(-8, buffer.getDecimalPoint());
        buffer.reset();

        DoubleConversion.bignumDtoa(3.9292015898194142585311918e-10, DtoaMode.SHORTEST, 0, buffer);
        assertEquals("39292015898194143", buffer.getRawDigits());
        buffer.reset();

        v = 4194304.0;
        DoubleConversion.bignumDtoa(v, DtoaMode.FIXED, 5, buffer);
        assertTrue(5 >= buffer.getLength() - buffer.getDecimalPoint());
        assertEquals("4194304", trimRepresentation(buffer.getRawDigits()));
        buffer.reset();

        v = 3.3161339052167390562200598e-237;
        DoubleConversion.bignumDtoa(v, DtoaMode.PRECISION, 19, buffer);
        assertTrue(19 >= buffer.getLength());
        assertEquals("3316133905216739056", trimRepresentation(buffer.getRawDigits()));
        assertEquals(-236, buffer.getDecimalPoint());
        buffer.reset();

        v = 7.9885183916008099497815232e+191;
        DoubleConversion.bignumDtoa(v, DtoaMode.PRECISION, 4, buffer);
        assertTrue(4 >= buffer.getLength());
        assertEquals("7989", trimRepresentation(buffer.getRawDigits()));
        assertEquals(192, buffer.getDecimalPoint());
        buffer.reset();

        v = 1.0000000000000012800000000e+17;
        DoubleConversion.bignumDtoa(v, DtoaMode.FIXED, 1, buffer);
        assertTrue(1 >= buffer.getLength() - buffer.getDecimalPoint());
        assertEquals("100000000000000128", trimRepresentation(buffer.getRawDigits()));
        assertEquals(18, buffer.getDecimalPoint());
        buffer.reset();
    }


    @Test
    public void testBignumShortest() {
        new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("resources/gay-shortest.txt")))
                .lines()
                .forEach(line -> {
                    if (line.isEmpty() || line.startsWith("//")) {
                        return; // comment or empty line
                    }
                    final String[] tokens = line.split(",\\s+");
                    assertEquals(tokens.length, 3, "*" + line + "*");
                    final double v = Double.parseDouble(tokens[0]);
                    final String str = tokens[1].replace('"', ' ').trim();;
                    final int point = Integer.parseInt(tokens[2]);
                    final DtoaBuffer buffer = new DtoaBuffer(BUFFER_SIZE);

                    DoubleConversion.bignumDtoa(v, DtoaMode.SHORTEST, 0, buffer);
                    assertEquals(str, buffer.getRawDigits());
                    assertEquals(point, buffer.getDecimalPoint());
                });
    }

    @Test
    public void testBignumFixed()  {
        new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("resources/gay-fixed.txt")))
                .lines()
                .forEach(line -> {
                    if (line.isEmpty() || line.startsWith("//")) {
                        return; // comment or empty line
                    }
                    final String[] tokens = line.split(",\\s+");
                    assertEquals(tokens.length, 4);
                    final double v = Double.parseDouble(tokens[0]);
                    final int digits = Integer.parseInt(tokens[1]);
                    final String str = tokens[2].replace('"', ' ').trim();
                    final int point = Integer.parseInt(tokens[3]);
                    final DtoaBuffer buffer = new DtoaBuffer(BUFFER_SIZE);

                    DoubleConversion.bignumDtoa(v, DtoaMode.FIXED, digits, buffer);
                    assertEquals(str, trimRepresentation(buffer.getRawDigits()));
                    assertEquals(point, buffer.getDecimalPoint());
                });
    }

    @Test
    public void testBignumPrecision() {
        new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("resources/gay-precision.txt")))
                .lines()
                .forEach(line -> {
                    if (line.isEmpty() || line.startsWith("//")) {
                        return; // comment or empty line
                    }
                    final String[] tokens = line.split(",\\s+");
                    assertEquals(tokens.length, 4);
                    final double v = Double.parseDouble(tokens[0]);
                    final int digits = Integer.parseInt(tokens[1]);
                    final String str = tokens[2].replace('"', ' ').trim();
                    final int point = Integer.parseInt(tokens[3]);
                    final DtoaBuffer buffer = new DtoaBuffer(BUFFER_SIZE);

                    DoubleConversion.bignumDtoa(v, DtoaMode.PRECISION, digits, buffer);
                    assertEquals(str, trimRepresentation(buffer.getRawDigits()));
                    assertEquals(point, buffer.getDecimalPoint());
                });
    }

}