/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.text.numbers;

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;
import java.util.Random;
import java.util.function.DoubleFunction;
import java.util.function.Function;
import java.util.stream.Stream;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

class DoubleFormatTest {

    private static void assertLocalizedFormatsAreEqual(final double d, final DecimalFormat df,
            final DoubleFunction<String> fmt, final Locale loc) {
        // NOTE: Perform the string comparison only on non-format characters. This is required because
        // JDK 16 adds directionality characters to strings for certain locales, such as Arabic, whereas
        // previous JDKs do not. We will match the behavior of the previous versions here and ignore formatting
        // for test purposes.
        final String dfStr = trimFormatChars(df.format(d));
        final String fmtStr = trimFormatChars(fmt.apply(d));

        try {
            Assertions.assertEquals(dfStr, fmtStr,
                () -> "Unexpected output for locale [" + loc.toLanguageTag() + "] and double value " + d);
        } catch (final AssertionError e) {
            // Note:
            // The DecimalFormat may omit the fraction component if it is zero
            // when using the ENGINEERING format "##0.0##E0".
            // e.g. new DecimalFormat("##0.0##E0").format(1.1299999e-4) => 113E-6.
            // The DoubleFormat class either always includes the zero or removes it
            // with the setting includeFractionPlaceholder(false).
            // Since we expect this mismatch we can remove the decimal point followed
            // by a zero from the DoubleFormat output.
            // This effectively checks: abcExyz == abc.0Exyz
            final DecimalFormatSymbols dfs = new DecimalFormatSymbols(loc);
            final char decimalSeparator = dfs.getDecimalSeparator();
            final char zeroDigit = dfs.getZeroDigit();
            final String updated = fmtStr.replace(new String(new char[] {decimalSeparator, zeroDigit}), "");
            if (dfStr.equals(updated)) {
                return;
            }
            throw e;
        }
    }

    private static void checkDefaultFormatSpecial(final DoubleFunction<String> fmt) {
        checkFormat(fmt, 0.0, "0.0");
        checkFormat(fmt, -0.0, "-0.0");
        checkFormat(fmt, Double.NaN, "NaN");
        checkFormat(fmt, Double.POSITIVE_INFINITY, "Infinity");
        checkFormat(fmt, Double.NEGATIVE_INFINITY, "-Infinity");
    }

    private static void checkFormat(final DoubleFunction<String> fmt, final double d, final String str) {
        Assertions.assertEquals(str, fmt.apply(d));
    }

    /**
     * Check that the given double value can be exactly recovered from formatted string representation
     * produced by the format instance.
     * @param fmt format instance
     * @param d input double value
     */
    private static void checkFormatAccuracy(final DoubleFunction<String> fmt, final double d) {
        final String str = fmt.apply(d);
        final double parsed = Double.parseDouble(str);
        Assertions.assertEquals(d, parsed, () -> "Formatted double string [" + str + "] did not match input value");
    }

    /**
     * Check that the given format type correctly formats doubles when using the
     * default configuration options. The format itself is not checked; only the
     * fact that the input double can be successfully recovered using {@link Double#parseDouble(String)}
     * is asserted.
     * @param type format type
     */
    private static void checkFormatAccuracyWithDefaults(final DoubleFormat type) {
        final DoubleFunction<String> fmt = type.builder().get();

        checkDefaultFormatSpecial(fmt);

        checkFormatAccuracy(fmt, Double.MIN_VALUE);
        checkFormatAccuracy(fmt, -Double.MIN_VALUE);

        checkFormatAccuracy(fmt, Double.MIN_NORMAL);
        checkFormatAccuracy(fmt, -Double.MIN_NORMAL);

        checkFormatAccuracy(fmt, Double.MAX_VALUE);
        checkFormatAccuracy(fmt, -Double.MAX_VALUE);

        checkFormatAccuracy(fmt, Math.PI);
        checkFormatAccuracy(fmt, Math.E);

        final Random rnd = new Random(10L);
        final int cnt = 1000;
        for (int i = 0; i < cnt; ++i) {
            checkFormatAccuracy(fmt, randomDouble(rnd));
        }
    }

    private static void checkLocalizedFormat(final Locale loc, final String pattern,
            final Function<Locale, DoubleFunction<String>> factory) {
        // arrange
        final DecimalFormat df = new DecimalFormat(pattern, DecimalFormatSymbols.getInstance(loc));
        final DoubleFunction<String> fmt = factory.apply(loc);

        // act/assert
        assertLocalizedFormatsAreEqual(0.0, df, fmt, loc);
        assertLocalizedFormatsAreEqual(Double.POSITIVE_INFINITY, df, fmt, loc);
        assertLocalizedFormatsAreEqual(Double.NEGATIVE_INFINITY, df, fmt, loc);
        assertLocalizedFormatsAreEqual(Double.NaN, df, fmt, loc);

        assertLocalizedFormatsAreEqual(1.0, df, fmt, loc);
        assertLocalizedFormatsAreEqual(-1.0, df, fmt, loc);
        assertLocalizedFormatsAreEqual(Math.PI, df, fmt, loc);
        assertLocalizedFormatsAreEqual(Math.E, df, fmt, loc);

        // Locales are tested using:
        // DecimalFormat   DoubleFormat
        // ##0.0##E0     : ENGINEERING  maPrecision=6
        // 0.0##         : PLAIN        minDecimalExponent(-3)
        // #,##0.0##     : PLAIN        minDecimalExponent(-3)
        // 0.0##E0       : SCIENTIFIC   maPrecision=4
        // The data should not test full precision (17 digits) of the PLAIN format.
        // Set the exponent range to create decimals with exponents of approximately
        // 10^7 to 10^-7: log2(1e7) = 23.25.
        final Random rnd = new Random(12L);
        final int minExp = -24;
        final int maxExp = 24;
        final int cnt = 1000;
        for (int i = 0; i < cnt; ++i) {
            assertLocalizedFormatsAreEqual(randomDouble(minExp, maxExp, rnd), df, fmt, loc);
        }
    }

    private static void checkLocalizedFormats(final String pattern, final Function<Locale, DoubleFunction<String>> factory) {
        for (final Locale loc : Locale.getAvailableLocales()) {
            checkLocalizedFormat(loc, pattern, factory);
        }
    }

    /**
     * Create a random double value with exponent in the range {@code [minExp, maxExp]}.
     * @param minExp minimum exponent; must be less than {@code maxExp}
     * @param maxExp maximum exponent; must be greater than {@code minExp}
     * @param rnd random number generator
     * @return random double
     */
    private static double randomDouble(final int minExp, final int maxExp, final Random rnd) {
        // Create random doubles using random bits in the sign bit and the mantissa.
        final long mask = (1L << 52) - 1 | 1L << 63;
        final long bits = rnd.nextLong() & mask;
        // The exponent must be unsigned so + 1023 to the signed exponent
        final long exp = rnd.nextInt(maxExp - minExp + 1) + minExp + 1023;
        return Double.longBitsToDouble(bits | exp << 52);
    }

    /**
     * Create a random double value using the full range of exponent values.
     * @param rnd random number generator
     * @return random double
     */
    private static double randomDouble(final Random rnd) {
        return randomDouble(Double.MIN_EXPONENT, Double.MAX_EXPONENT, rnd);
    }

    static Stream<Arguments> testMaximumPrecision() {
        return Stream.of(
            // Example of different Double.toString representations across JDKs
            // JDK 17: -9.3540047119774374E17
            // JDK 21: -9.354004711977437E17
            Arguments.of(DoubleFormat.PLAIN.builder().get(), -9.3540047119774374E17),
            Arguments.of(DoubleFormat.SCIENTIFIC.builder().get(), -9.3540047119774374E17)
        );
    }

    /**
     * Remove Unicode {@link Character#FORMAT format} characters from the given string.
     * @param str input string
     * @return input string with format characters removed
     */
    private static String trimFormatChars(final String str) {
        final StringBuilder sb = new StringBuilder();
        for (final char c : str.toCharArray()) {
            if (Character.getType(c) != Character.FORMAT) {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    @Test
    void testBuilder_illegalArgs() {
        // arrange
        final DoubleFormat.Builder builder = DoubleFormat.PLAIN.builder();

        // act/assert
        Assertions.assertThrows(NullPointerException.class, () -> builder.digits(null));
        Assertions.assertThrows(IllegalArgumentException.class, () -> builder.digits("a"));
        Assertions.assertThrows(IllegalArgumentException.class, () -> builder.digits("0123456789a"));

        Assertions.assertThrows(NullPointerException.class, () -> builder.exponentSeparator(null));
        Assertions.assertThrows(NullPointerException.class, () -> builder.infinity(null));
        Assertions.assertThrows(NullPointerException.class, () -> builder.nan(null));
        Assertions.assertThrows(NullPointerException.class, () -> builder.formatSymbols(null));
    }

    @Test
    void testCustomDigitString() {
        // arrange
        final String digits = "abcdefghij";
        final DoubleFunction<String> plain = DoubleFormat.PLAIN.builder().digits(digits).get();
        final DoubleFunction<String> sci = DoubleFormat.SCIENTIFIC.builder().digits(digits).get();
        final DoubleFunction<String> eng = DoubleFormat.ENGINEERING.builder().digits(digits).get();
        final DoubleFunction<String> mixed = DoubleFormat.MIXED.builder().digits(digits).get();

        // act/assert
        checkFormat(plain, 9876543210.0, "jihgfedcba.a");
        checkFormat(sci, 9876543210.0, "j.ihgfedcbEj");
        checkFormat(eng, 9876543210.0, "j.ihgfedcbEj");
        checkFormat(mixed, 9876543210.0, "j.ihgfedcbEj");
    }

    @Test
    void testEngineering_custom() {
        // act
        final DoubleFunction<String> fmt = DoubleFormat.ENGINEERING.builder()
                .maxPrecision(3)
                .minDecimalExponent(-3)
                .allowSignedZero(false)
                .includeFractionPlaceholder(false)
                .decimalSeparator(',')
                .exponentSeparator("e")
                .infinity("inf")
                .nan("nan")
                .minusSign('!')
                .get();

        // act/assert
        checkFormat(fmt, Double.NaN, "nan");
        checkFormat(fmt, Double.POSITIVE_INFINITY, "inf");
        checkFormat(fmt, Double.NEGATIVE_INFINITY, "!inf");

        checkFormat(fmt, 0.00001, "0");
        checkFormat(fmt, -0.0001, "0");
        checkFormat(fmt, 0.001, "1e!3");
        checkFormat(fmt, -0.01, "!10e!3");
        checkFormat(fmt, 0.1, "100e!3");
        checkFormat(fmt, -0.0, "0");
        checkFormat(fmt, 0.0, "0");
        checkFormat(fmt, -1.0, "!1");
        checkFormat(fmt, 10.0, "10");
        checkFormat(fmt, -100.0, "!100");
        checkFormat(fmt, 1000.0, "1e3");
        checkFormat(fmt, -10000.0, "!10e3");
        checkFormat(fmt, 100000.0, "100e3");
        checkFormat(fmt, -1000000.0, "!1e6");
        checkFormat(fmt, 10000000.0, "10e6");
        checkFormat(fmt, -100000000.0, "!100e6");

        checkFormat(fmt, 1.25e-3, "1e!3");
        checkFormat(fmt, -9.975e-4, "!1e!3");
        checkFormat(fmt, 12345, "12,3e3");
        checkFormat(fmt, -9_999_999, "!10e6");
        checkFormat(fmt, 1.00001e7, "10e6");

        checkFormat(fmt, Double.MAX_VALUE, "180e306");
        checkFormat(fmt, Double.MIN_VALUE, "0");
        checkFormat(fmt, Double.MIN_NORMAL, "0");
        checkFormat(fmt, Math.PI, "3,14");
        checkFormat(fmt, Math.E, "2,72");
    }

    @Test
    void testEngineering_defaults() {
        // act
        final DoubleFunction<String> fmt = DoubleFormat.ENGINEERING.builder()
                .get();

        // act/assert
        checkDefaultFormatSpecial(fmt);

        checkFormat(fmt, 0.00001, "10.0E-6");
        checkFormat(fmt, -0.0001, "-100.0E-6");
        checkFormat(fmt, 0.001, "1.0E-3");
        checkFormat(fmt, -0.01, "-10.0E-3");
        checkFormat(fmt, 0.1, "100.0E-3");
        checkFormat(fmt, -0.0, "-0.0");
        checkFormat(fmt, 0.0, "0.0");
        checkFormat(fmt, -1.0, "-1.0");
        checkFormat(fmt, 10.0, "10.0");
        checkFormat(fmt, -100.0, "-100.0");
        checkFormat(fmt, 1000.0, "1.0E3");
        checkFormat(fmt, -10000.0, "-10.0E3");
        checkFormat(fmt, 100000.0, "100.0E3");
        checkFormat(fmt, -1000000.0, "-1.0E6");
        checkFormat(fmt, 10000000.0, "10.0E6");
        checkFormat(fmt, -100000000.0, "-100.0E6");

        checkFormat(fmt, 1.25e-3, "1.25E-3");
        checkFormat(fmt, -9.975e-4, "-997.5E-6");
        checkFormat(fmt, 12345, "12.345E3");
        checkFormat(fmt, -9_999_999, "-9.999999E6");
        checkFormat(fmt, 1.00001e7, "10.0001E6");

        checkFormat(fmt, Double.MAX_VALUE, "179.76931348623157E306");
        checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
        checkFormat(fmt, Double.MIN_NORMAL, "22.250738585072014E-309");
        checkFormat(fmt, Math.PI, "3.141592653589793");
        checkFormat(fmt, Math.E, "2.718281828459045");
    }

    @Test
    void testEngineering_localeFormatComparison() {
        // act/assert
        checkLocalizedFormats("##0.0##E0", loc -> DoubleFormat.ENGINEERING.builder()
                .maxPrecision(6)
                .alwaysIncludeExponent(true)
                .formatSymbols(DecimalFormatSymbols.getInstance(loc))
                .get());
    }

    @Test
    void testFormatAccuracy() {
        // act/assert
        checkFormatAccuracyWithDefaults(DoubleFormat.PLAIN);
        checkFormatAccuracyWithDefaults(DoubleFormat.MIXED);
        checkFormatAccuracyWithDefaults(DoubleFormat.SCIENTIFIC);
        checkFormatAccuracyWithDefaults(DoubleFormat.ENGINEERING);
    }

    /**
     * Test formatting at the maximum precision. The formatting is based on the output
     * of {@link Double#toString()}. If cannot create an extended precision text
     * representation and is limited to 17 significant digits. This test verifies that
     * formatting does not lose information that would be required to recreate the
     * same double value.
     */
    @ParameterizedTest
    @MethodSource
    void testMaximumPrecision(final DoubleFunction<String> fmt, final double value) {
        final String s = fmt.apply(value);
        final double d = Double.parseDouble(s);
        Assertions.assertEquals(value, d, () -> value + " formatted as " + s);
    }

    @Test
    void testMixed_custom() {
        // arrange
        final DoubleFunction<String> fmt = DoubleFormat.MIXED.builder()
                .maxPrecision(3)
                .minDecimalExponent(-3)
                .allowSignedZero(false)
                .includeFractionPlaceholder(false)
                .decimalSeparator(',')
                .plainFormatMaxDecimalExponent(4)
                .plainFormatMinDecimalExponent(-1)
                .exponentSeparator("e")
                .infinity("inf")
                .nan("nan")
                .minusSign('!')
                .get();

        // act/assert
        checkFormat(fmt, Double.NaN, "nan");
        checkFormat(fmt, Double.POSITIVE_INFINITY, "inf");
        checkFormat(fmt, Double.NEGATIVE_INFINITY, "!inf");

        checkFormat(fmt, 0.00001, "0");
        checkFormat(fmt, -0.0001, "0");
        checkFormat(fmt, 0.001, "1e!3");
        checkFormat(fmt, -0.01, "!1e!2");
        checkFormat(fmt, 0.1, "0,1");
        checkFormat(fmt, -0.0, "0");
        checkFormat(fmt, 0.0, "0");
        checkFormat(fmt, -1.0, "!1");
        checkFormat(fmt, 10.0, "10");
        checkFormat(fmt, -100.0, "!100");
        checkFormat(fmt, 1000.0, "1000");
        checkFormat(fmt, -10000.0, "!10000");
        checkFormat(fmt, 100000.0, "1e5");
        checkFormat(fmt, -1000000.0, "!1e6");
        checkFormat(fmt, 10000000.0, "1e7");
        checkFormat(fmt, -100000000.0, "!1e8");

        checkFormat(fmt, 1.25e-3, "1e!3");
        checkFormat(fmt, -9.975e-4, "!1e!3");
        checkFormat(fmt, 12345, "12300");
        checkFormat(fmt, -9_999_999, "!1e7");
        checkFormat(fmt, 1.00001e7, "1e7");

        checkFormat(fmt, Double.MAX_VALUE, "1,8e308");
        checkFormat(fmt, Double.MIN_VALUE, "0");
        checkFormat(fmt, Double.MIN_NORMAL, "0");
        checkFormat(fmt, Math.PI, "3,14");
        checkFormat(fmt, Math.E, "2,72");
    }

    @Test
    void testMixed_defaults() {
        // arrange
        testMixed_defaults(DoubleFormat.MIXED.builder().get());
    }

    private void testMixed_defaults(final DoubleFunction<String> fmt) {
        // act/assert
        checkDefaultFormatSpecial(fmt);

        checkFormat(fmt, 0.00001, "1.0E-5");
        checkFormat(fmt, -0.0001, "-1.0E-4");
        checkFormat(fmt, 0.001, "0.001");
        checkFormat(fmt, -0.01, "-0.01");
        checkFormat(fmt, 0.1, "0.1");
        checkFormat(fmt, -0.0, "-0.0");
        checkFormat(fmt, 0.0, "0.0");
        checkFormat(fmt, -1.0, "-1.0");
        checkFormat(fmt, 10.0, "10.0");
        checkFormat(fmt, -100.0, "-100.0");
        checkFormat(fmt, 1000.0, "1000.0");
        checkFormat(fmt, -10000.0, "-10000.0");
        checkFormat(fmt, 100000.0, "100000.0");
        checkFormat(fmt, -1000000.0, "-1000000.0");
        checkFormat(fmt, 10000000.0, "1.0E7");
        checkFormat(fmt, -100000000.0, "-1.0E8");

        checkFormat(fmt, 1.25e-3, "0.00125");
        checkFormat(fmt, -9.975e-4, "-9.975E-4");
        checkFormat(fmt, 12345, "12345.0");
        checkFormat(fmt, -9_999_999, "-9999999.0");
        checkFormat(fmt, 1.00001e7, "1.00001E7");

        checkFormat(fmt, Double.MAX_VALUE, "1.7976931348623157E308");
        checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
        checkFormat(fmt, Double.MIN_NORMAL, "2.2250738585072014E-308");
        checkFormat(fmt, Math.PI, "3.141592653589793");
        checkFormat(fmt, Math.E, "2.718281828459045");
    }

    @Test
    void testMixed_defaultsDeprecated() {
        testMixed_defaults(DoubleFormat.MIXED.builder().build());
    }

    @Test
    void testPlain_custom() {
        // arrange
        final DoubleFunction<String> fmt = DoubleFormat.PLAIN.builder()
            .maxPrecision(3)
            .minDecimalExponent(-3)
            .allowSignedZero(false)
            .includeFractionPlaceholder(false)
            .decimalSeparator(',')
            .exponentSeparator("e")
            .infinity("inf")
            .nan("nan")
            .minusSign('!')
            .get();

        // act/assert
        checkFormat(fmt, Double.NaN, "nan");
        checkFormat(fmt, Double.POSITIVE_INFINITY, "inf");
        checkFormat(fmt, Double.NEGATIVE_INFINITY, "!inf");

        checkFormat(fmt, 0.00001, "0");
        checkFormat(fmt, -0.0001, "0");
        checkFormat(fmt, 0.001, "0,001");
        checkFormat(fmt, -0.01, "!0,01");
        checkFormat(fmt, 0.1, "0,1");
        checkFormat(fmt, -0.0, "0");
        checkFormat(fmt, 0.0, "0");
        checkFormat(fmt, -1.0, "!1");
        checkFormat(fmt, 10.0, "10");
        checkFormat(fmt, -100.0, "!100");
        checkFormat(fmt, 1000.0, "1000");
        checkFormat(fmt, -10000.0, "!10000");
        checkFormat(fmt, 100000.0, "100000");
        checkFormat(fmt, -1000000.0, "!1000000");
        checkFormat(fmt, 10000000.0, "10000000");
        checkFormat(fmt, -100000000.0, "!100000000");

        checkFormat(fmt, 1.25e-3, "0,001");
        checkFormat(fmt, -9.975e-4, "!0,001");
        checkFormat(fmt, 12345, "12300");
        checkFormat(fmt, -9_999_999, "!10000000");
        checkFormat(fmt, 1.00001e7, "10000000");

        checkFormat(fmt, Float.MAX_VALUE, "340000000000000000000000000000000000000");
        checkFormat(fmt, -Float.MIN_VALUE, "0");
        checkFormat(fmt, Float.MIN_NORMAL, "0");
        checkFormat(fmt, Math.PI, "3,14");
        checkFormat(fmt, Math.E, "2,72");
    }

    @Test
    void testPlain_defaults() {
        // arrange
        final DoubleFunction<String> fmt = DoubleFormat.PLAIN.builder()
            .get();

        // act/assert
        checkFormat(fmt, 0.00001, "0.00001");
        checkFormat(fmt, -0.0001, "-0.0001");
        checkFormat(fmt, 0.001, "0.001");
        checkFormat(fmt, -0.01, "-0.01");
        checkFormat(fmt, 0.1, "0.1");
        checkFormat(fmt, -0.0, "-0.0");
        checkFormat(fmt, 0.0, "0.0");
        checkFormat(fmt, -1.0, "-1.0");
        checkFormat(fmt, 10.0, "10.0");
        checkFormat(fmt, -100.0, "-100.0");
        checkFormat(fmt, 1000.0, "1000.0");
        checkFormat(fmt, -10000.0, "-10000.0");
        checkFormat(fmt, 100000.0, "100000.0");
        checkFormat(fmt, -1000000.0, "-1000000.0");
        checkFormat(fmt, 10000000.0, "10000000.0");
        checkFormat(fmt, -100000000.0, "-100000000.0");

        checkFormat(fmt, 1.25e-3, "0.00125");
        checkFormat(fmt, -9.975e-4, "-0.0009975");
        checkFormat(fmt, 12345, "12345.0");
        checkFormat(fmt, -9_999_999, "-9999999.0");
        checkFormat(fmt, 1.00001e7, "10000100.0");

        checkFormat(fmt, Float.MAX_VALUE, "340282346638528860000000000000000000000.0");
        checkFormat(fmt, -Float.MIN_VALUE, "-0.000000000000000000000000000000000000000000001401298464324817");
        checkFormat(fmt, Float.MIN_NORMAL, "0.000000000000000000000000000000000000011754943508222875");
        checkFormat(fmt, Math.PI, "3.141592653589793");
        checkFormat(fmt, Math.E, "2.718281828459045");
    }

    @Test
    void testPlain_localeFormatComparison() {
        // act/assert
        checkLocalizedFormats("0.0##", loc -> DoubleFormat.PLAIN.builder()
                .minDecimalExponent(-3)
                .formatSymbols(DecimalFormatSymbols.getInstance(loc))
                .get());
        checkLocalizedFormats("#,##0.0##", loc -> DoubleFormat.PLAIN.builder()
                .minDecimalExponent(-3)
                .groupThousands(true)
                .formatSymbols(DecimalFormatSymbols.getInstance(loc))
                .get());
    }

    @Test
    void testScientific_custom() {
        // arrange
        final DoubleFunction<String> fmt = DoubleFormat.SCIENTIFIC.builder()
                .maxPrecision(3)
                .minDecimalExponent(-3)
                .allowSignedZero(false)
                .includeFractionPlaceholder(false)
                .decimalSeparator(',')
                .exponentSeparator("e")
                .infinity("inf")
                .nan("nan")
                .minusSign('!')
                .get();

        // act/assert
        checkFormat(fmt, Double.NaN, "nan");
        checkFormat(fmt, Double.POSITIVE_INFINITY, "inf");
        checkFormat(fmt, Double.NEGATIVE_INFINITY, "!inf");

        checkFormat(fmt, 0.00001, "0");
        checkFormat(fmt, -0.0001, "0");
        checkFormat(fmt, 0.001, "1e!3");
        checkFormat(fmt, -0.01, "!1e!2");
        checkFormat(fmt, 0.1, "1e!1");
        checkFormat(fmt, -0.0, "0");
        checkFormat(fmt, 0.0, "0");
        checkFormat(fmt, -1.0, "!1");
        checkFormat(fmt, 10.0, "1e1");
        checkFormat(fmt, -100.0, "!1e2");
        checkFormat(fmt, 1000.0, "1e3");
        checkFormat(fmt, -10000.0, "!1e4");
        checkFormat(fmt, 100000.0, "1e5");
        checkFormat(fmt, -1000000.0, "!1e6");
        checkFormat(fmt, 10000000.0, "1e7");
        checkFormat(fmt, -100000000.0, "!1e8");

        checkFormat(fmt, 1.25e-3, "1e!3");
        checkFormat(fmt, -9.975e-4, "!1e!3");
        checkFormat(fmt, 12345, "1,23e4");
        checkFormat(fmt, -9_999_999, "!1e7");
        checkFormat(fmt, 1.00001e7, "1e7");

        checkFormat(fmt, Double.MAX_VALUE, "1,8e308");
        checkFormat(fmt, Double.MIN_VALUE, "0");
        checkFormat(fmt, Double.MIN_NORMAL, "0");
        checkFormat(fmt, Math.PI, "3,14");
        checkFormat(fmt, Math.E, "2,72");
    }

    @Test
    void testScientific_defaults() {
        // arrange
        final DoubleFunction<String> fmt = DoubleFormat.SCIENTIFIC.builder().get();

        // act/assert
        checkDefaultFormatSpecial(fmt);

        checkFormat(fmt, 0.00001, "1.0E-5");
        checkFormat(fmt, -0.0001, "-1.0E-4");
        checkFormat(fmt, 0.001, "1.0E-3");
        checkFormat(fmt, -0.01, "-1.0E-2");
        checkFormat(fmt, 0.1, "1.0E-1");
        checkFormat(fmt, -0.0, "-0.0");
        checkFormat(fmt, 0.0, "0.0");
        checkFormat(fmt, -1.0, "-1.0");
        checkFormat(fmt, 10.0, "1.0E1");
        checkFormat(fmt, -100.0, "-1.0E2");
        checkFormat(fmt, 1000.0, "1.0E3");
        checkFormat(fmt, -10000.0, "-1.0E4");
        checkFormat(fmt, 100000.0, "1.0E5");
        checkFormat(fmt, -1000000.0, "-1.0E6");
        checkFormat(fmt, 10000000.0, "1.0E7");
        checkFormat(fmt, -100000000.0, "-1.0E8");

        checkFormat(fmt, 1.25e-3, "1.25E-3");
        checkFormat(fmt, -9.975e-4, "-9.975E-4");
        checkFormat(fmt, 12345, "1.2345E4");
        checkFormat(fmt, -9_999_999, "-9.999999E6");
        checkFormat(fmt, 1.00001e7, "1.00001E7");

        checkFormat(fmt, Double.MAX_VALUE, "1.7976931348623157E308");
        checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
        checkFormat(fmt, Double.MIN_NORMAL, "2.2250738585072014E-308");
        checkFormat(fmt, Math.PI, "3.141592653589793");
        checkFormat(fmt, Math.E, "2.718281828459045");
    }

    @Test
    void testScientific_localeFormatComparison() {
        // act/assert
        checkLocalizedFormats("0.0##E0", loc -> DoubleFormat.SCIENTIFIC.builder()
                .maxPrecision(4)
                .alwaysIncludeExponent(true)
                .formatSymbols(DecimalFormatSymbols.getInstance(loc))
                .get());
    }
}
