const BigFlo = require('./BigFlo');

const tests = [

    // Correctly operates on IEEE 754 quirks

    ['0.1 + 0.2 = 0.30000000000000004', () => {
        const actual = BigFlo('0.1').plus('0.2').toString();
        const expect = '0.3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.3 - 0.2 = 0.09999999999999998', () => {
        const actual = BigFlo('0.3').minus('0.2').toString();
        const expect = '0.1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.6 * 3 = 1.7999999999999998', () => {
        const actual = BigFlo('0.6').times('3').toString();
        const expect = '1.8';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['3 * 0.6 = 1.7999999999999998', () => {
        const actual = BigFlo('3').times('0.6').toString();
        const expect = '1.8';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.3 / 0.1 = 2.9999999999999996', () => {
        const actual = BigFlo('0.3').div('0.1').toString();
        const expect = '3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.1 / 0.3 = 0.33333333333333337', () => {
        const actual = BigFlo('0.1').div('0.3').toString();
        const expect = '0.333333333333333333333333333333333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.1 + 0.7 = 0.7999999999999999', () => {
        const actual = BigFlo('0.1').plus('0.7').toString();
        const expect = '0.8';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.2 * 0.2 = 0.04000000000000001', () => {
        const actual = BigFlo('0.2').times('0.2').toString();
        const expect = '0.04';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.7 - 0.4 = 0.29999999999999993', () => {
        const actual = BigFlo('0.7').minus('0.4').toString();
        const expect = '0.3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.3 / 0.2 = 1.4999999999999998', () => {
        const actual = BigFlo('0.3').div('0.2').toString();
        const expect = '1.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.000000003 / 0.2 = 1.5e-8', () => {
        const actual = BigFlo('0.000000003').div('0.2').toString();
        const expect = '0.000000015';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.0002 / 0.0000000017 = 117647.05882352943', () => {
        const actual = BigFlo('0.0002').div('0.0000000017').toString();
        const expect = '117647.05882352941176470588235294117647';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.0000000017 / 0.0002 = 0.0000085', () => {
        const actual = BigFlo('0.0000000017').div('0.0002').toString();
        const expect = '0.0000085';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 / 17 = 0.058823529411764705', () => {
        const actual = BigFlo('1').div('17').toString();
        const expect = '0.05882352941176470588235294117647';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999 * 0.0000 = 0', () => {
        const actual = BigFlo('999').times('0.0000').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-0.3 + 0.3 = 0', () => {
        const actual = BigFlo('-0.3').plus('0.3').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.3 - 0.3 = 0', () => {
        const actual = BigFlo('0.3').minus('0.3').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['(0.1 + 0.2) - 0.3 = 5.551115123125783e-17', () => {
        const actual = BigFlo('0.1').plus('0.2').minus('0.3').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(0.1)['+'](0.2)", () => {
        const actual = BigFlo(0.1)['+'](0.2).toString();
        const expect = '0.3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(0.1)['-'](0.2)", () => {
        const actual = BigFlo(0.1)['-'](0.2).toString();
        const expect = '-0.1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(0.1)['*'](0.2)", () => {
        const actual = BigFlo(0.1)['*'](0.2).toString();
        const expect = '0.02';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(0.1).multipliedBy(0.2)", () => {
        const actual = BigFlo(0.1).multipliedBy(0.2).toString();
        const expect = '0.02';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(0.1)['/'](0.2)", () => {
        const actual = BigFlo(0.1)['/'](0.2).toString();
        const expect = '0.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["STATIC PRECISION 0: BigFlo(22)['/'](17)", () => {
        const originalPrecision = BigFlo().getDivisionPrecision();
        BigFlo.setDivisionPrecision(0);
        const actual = BigFlo(22)['/'](17).toString();
        BigFlo.setDivisionPrecision(originalPrecision);
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["STATIC PRECISION 1: BigFlo(22)['/'](17)", () => {
        const originalPrecision = BigFlo().getDivisionPrecision();
        BigFlo.setDivisionPrecision(1);
        const actual = BigFlo(22)['/'](17).toString();
        BigFlo.setDivisionPrecision(originalPrecision);
        const expect = '1.2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["STATIC PRECISION 2: BigFlo(22)['/'](17)", () => {
        const originalPrecision = BigFlo().getDivisionPrecision();
        BigFlo.setDivisionPrecision(2);
        const actual = BigFlo(22)['/'](17).toString();
        BigFlo.setDivisionPrecision(originalPrecision);
        const expect = '1.29';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["STATIC PRECISION 3: BigFlo(22)['/'](17)", () => {
        const originalPrecision = BigFlo().getDivisionPrecision();
        BigFlo.setDivisionPrecision(3);
        const actual = BigFlo(22)['/'](17).toString();
        BigFlo.setDivisionPrecision(originalPrecision);
        const expect = '1.294';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["INSTANCE PRECISION 4: BigFlo(22).setDivisionPrecision(4)['/'](17)", () => {
        const actual = BigFlo(22).setDivisionPrecision(4)['/'](17).toString();
        const expect = '1.2941';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(0.1).dividedBy(0.2)", () => {
        const actual = BigFlo(0.1).dividedBy(0.2).toString();
        const expect = '0.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(5)['**'](6)", () => {
        const actual = BigFlo(5)['**'](6).toString();
        const expect = '15625';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["BigFlo(5).toThePowerOf(6)", () => {
        const actual = BigFlo(5).toThePowerOf(6).toString();
        const expect = '15625';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['9999999999999999999999999999999999999999999999999999999999999n + 0.1 = TypeError: Cannot mix BigInt and other types', () => {
        const actual = BigFlo(9999999999999999999999999999999999999999999999999999999999999n).plus(0.1).toString();
        const expect = '9999999999999999999999999999999999999999999999999999999999999.1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity + 1 = Infinity', () => {
        const actual = BigFlo('Infinity').plus('1').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 + Infinity = Infinity', () => {
        const actual = BigFlo('1').plus('Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity + 1 = -Infinity', () => {
        const actual = BigFlo('-Infinity').plus('1').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity + -1 = Infinity', () => {
        const actual = BigFlo('Infinity').plus('-1').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity + -1 = -Infinity', () => {
        const actual = BigFlo('-Infinity').plus('-1').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 + Infinity = Infinity', () => {
        const actual = BigFlo('-1').plus('Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 + -Infinity = -Infinity', () => {
        const actual = BigFlo('1').plus('-Infinity').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 + -Infinity = -Infinity', () => {
        const actual = BigFlo('-1').plus('-Infinity').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity - 1 = Infinity', () => {
        const actual = BigFlo('Infinity').minus('1').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity - -1 = Infinity', () => {
        const actual = BigFlo('Infinity').minus('-1').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity - 1 = -Infinity', () => {
        const actual = BigFlo('-Infinity').minus('1').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity - -1 = -Infinity', () => {
        const actual = BigFlo('-Infinity').minus('-1').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 - Infinity = -Infinity', () => {
        const actual = BigFlo('1').minus('Infinity').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 - -Infinity = Infinity', () => {
        const actual = BigFlo('1').minus('-Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 - Infinity = -Infinity', () => {
        const actual = BigFlo('-1').minus('Infinity').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 - -Infinity = Infinity', () => {
        const actual = BigFlo('-1').minus('-Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity / 999 = Infinity', () => {
        const actual = BigFlo('Infinity').div('999').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity / 999 = -Infinity', () => {
        const actual = BigFlo('-Infinity').div('999').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity / -999 = -Infinity', () => {
        const actual = BigFlo('Infinity').div('-999').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity / -999 = Infinity', () => {
        const actual = BigFlo('-Infinity').div('-999').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999 / Infinity = 0', () => {
        const actual = BigFlo('999').div('Infinity').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-999 / Infinity = 0', () => {
        const actual = BigFlo('-999').div('Infinity').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999 / -Infinity = 0', () => {
        const actual = BigFlo('999').div('-Infinity').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-999 / -Infinity = 0', () => {
        const actual = BigFlo('-999').div('-Infinity').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity * 999 = Infinity', () => {
        const actual = BigFlo('Infinity').times('999').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity * -999 = -Infinity', () => {
        const actual = BigFlo('Infinity').times('-999').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity * 999 = -Infinity', () => {
        const actual = BigFlo('-Infinity').times('999').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity * -999 = Infinity', () => {
        const actual = BigFlo('-Infinity').times('-999').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999 * Infinity = Infinity', () => {
        const actual = BigFlo('999').times('Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 / 0 = Infinity', () => {
        const actual = BigFlo('1').div('0').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 / 0 = -Infinity', () => {
        const actual = BigFlo('-1').div('0').toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity + Infinity = Infinity', () => {
        const actual = BigFlo('Infinity').plus('Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity - Infinity = NaN', () => {
        const actual = BigFlo('Infinity').minus('Infinity').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity * Infinity = Infinity', () => {
        const actual = BigFlo('Infinity').times('Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity / Infinity = NaN', () => {
        const actual = BigFlo('Infinity').div('Infinity').toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1e20 + 2 = 100000000000000000000', () => {
        const actual = BigFlo('1e20').plus('2').toString();
        const expect = '100000000000000000002';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1.7976931348623157E+308 + 1E100 = 1.7976931348623157e+308', () => {
        // test uppercase E for scientific notation
        const actual = BigFlo('1.7976931348623157E+308').plus('1E100').toString();
        const expect = '179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1.7976931348623157e+308 + 1 = 1.7976931348623157e+308', () => {
        const actual = BigFlo('1.7976931348623157e+308').plus('1').toString();
        const expect = '179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1.7976931348623157e3 + 1 = 1798.6931348623157', () => {
        const actual = BigFlo('1.7976931348623157e3').plus('1').toString();
        const expect = '1798.6931348623157';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1.7976931348623157e-3 + 1 = 1.0017976931348622', () => {
        const actual = BigFlo('1.7976931348623157e-3').plus('1').toString();
        const expect = '1.0017976931348623157';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1.7976931348623157e3 + 1 = -1796.6931348623157', () => {
        const actual = BigFlo('-1.7976931348623157e3').plus('1').toString();
        const expect = '-1796.6931348623157';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1.7976931348623157e-3 + 1 = 0.9982023068651377', () => {
        const actual = BigFlo('-1.7976931348623157e-3').plus('1').toString();
        const expect = '0.9982023068651376843';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['+1.7976931348623157e+3 + 1 = 1798.6931348623157', () => {
        const actual = BigFlo('+1.7976931348623157e+3').plus('1').toString();
        const expect = '1798.6931348623157';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['5.210724853226596e+19 / -2.4665402933587313e+18 = -21.125642533619672', () => {
        const actual = BigFlo('5.210724853226596e+19').div('-2.4665402933587313e+18').toString();
        const expect = '-21.125642533619673080515665012187826';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1.0985079557484118e+19 * 5.27589707150934e+19 = 5.795614906762758e+38', () => {
        const actual = BigFlo('1.0985079557484118e+19').times('5.27589707150934e+19').toString();
        const expect = '579561490676275747070273386621200000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['4.317475246251447e+19 * -8.939481046292968e+19 = -3.859598813170388e+39', () => {
        const actual = BigFlo('4.317475246251447e+19').times('-8.939481046292968e+19').toString();
        const expect = '-3859598813170387509451735592469600000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-5.342924760212046e+18 * -6.6229222549858615e+19 = 3.538577530112335e+38', () => {
        const actual = BigFlo('-5.342924760212046e+18').times('-6.6229222549858615e+19').toString();
        const expect = '353857753011233570307614719876290000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-4.012297521931832e+19 / -6.061001654149693e+18 = 6.619858813575465', () => {
        const actual = BigFlo('-4.012297521931832e+19').div('-6.061001654149693e+18').toString();
        const expect = '6.619858813575465405180608429034145';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Handle NaN constructor', () => {
        const actual = BigFlo(NaN).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Handle NaN constructor chain operations', () => {
        const actual = BigFlo(NaN).plus(9).minus(8).times(7).div(6).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Handle NaN in chain operations', () => {
        const actual = BigFlo(10).plus(9).minus(NaN).times(7).div(6).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Handle BigFlo NaN in chain operations', () => {
        const actual = BigFlo(10).plus(BigFlo(NaN)).minus(8).times(7).div(6).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['(((10+9)-8)*7)/6 = 12.833333333333334', () => {
        const actual = BigFlo(10).plus(9).minus(8).times(7).div(6).toString();
        const expect = '12.833333333333333333333333333333333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['((((((((10+9)-8)*7)/6)*6)/7)+8)-9) = 10', () => {
        const actual = BigFlo(10).plus(9).minus(8).times(7).div(6).times(6).div(7).plus(8).minus(9).toString();
        const expect = '10';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['(1 / 3) * 3 = 1', () => {
        const actual = BigFlo(1).div(3).times(3).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.3333333333333333 * 3 = 0.9999999999999999', () => {
        const actual = BigFlo('0.3333333333333333').times('3').toString();
        const expect = '0.9999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.33333333333333333333 * 3 = 0.99999999999999999999', () => {
        const actual = BigFlo('0.33333333333333333333').times('3').toString();
        const expect = '0.99999999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 0: 0.3 * 3 = 1', () => {
        const actual = BigFlo('0.3').setFractionalRoundingPrecision(0).times('3').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 1: 0.3 * 3 = 1', () => {
        const actual = BigFlo('0.3').setFractionalRoundingPrecision(1).times('3').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 2: 0.3 * 3 = 0.9', () => {
        const actual = BigFlo('0.3').setFractionalRoundingPrecision(2).times('3').toString();
        const expect = '0.9';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 2: 0.33 * 3 = 1', () => {
        const actual = BigFlo('0.33').setFractionalRoundingPrecision(2).times('3').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['STATIC FRACTIONAL ROUNDING PRECISION 5: 0.3333 * 3 = 0.9999', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(5);
        const actual = BigFlo('0.3333').times('3').toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '0.9999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['STATIC FRACTIONAL ROUNDING PRECISION 5: 0.33333 * 3 = 1', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(5);
        const actual = BigFlo('0.33333').times('3').toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['STATIC FRACTIONAL ROUNDING PRECISION 5: 0.333333 * 3 = 1', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(5);
        const actual = BigFlo('0.333333').times('3').toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 16: 0.3333333333333333 * 3 = 1', () => {
        const actual = BigFlo('0.3333333333333333').setFractionalRoundingPrecision(16).times('3').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 20: 0.33333333333333333333 * 3 = 1', () => {
        const actual = BigFlo('0.33333333333333333333').setFractionalRoundingPrecision(20).times('3').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 0: 9 / 10 = 1', () => {
        const actual = BigFlo('9').setFractionalRoundingPrecision(0)['/']('10').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 1: 99 / 100 = 1', () => {
        const actual = BigFlo('99').setFractionalRoundingPrecision(1)['/']('100').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 2: 9 / 10 = 0.9', () => {
        const actual = BigFlo('9').setFractionalRoundingPrecision(2)['/']('10').toString();
        const expect = '0.9';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 2: 99 / 100 = 1', () => {
        const actual = BigFlo('99').setFractionalRoundingPrecision(2)['/']('100').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['STATIC FRACTIONAL ROUNDING PRECISION 5: 9999 / 10000 = 0.9999', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(5);
        const actual = BigFlo('9999')['/']('10000').toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '0.9999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['STATIC FRACTIONAL ROUNDING PRECISION 5: 99999 / 100000 = 1', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(5);
        const actual = BigFlo('99999')['/']('100000').toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['STATIC FRACTIONAL ROUNDING PRECISION 5: 999999 / 1000000 = 1', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(5);
        const actual = BigFlo('999999')['/']('1000000').toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 16: 9999999999999999 / 10000000000000000 = 1', () => {
        const actual = BigFlo('9999999999999999').setFractionalRoundingPrecision(16)['/']('10000000000000000').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING PRECISION 20: 99999999999999999999 / 3 = 1', () => {
        const actual = BigFlo('99999999999999999999').setFractionalRoundingPrecision(20)['/']('100000000000000000000').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.333333333333333333333333333333333 * 3 = 1', () => {
        const actual = BigFlo('0.333333333333333333333333333333333').times('3').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.333333333333333333333333333333333333333333333333333333333333333333 * 3 = 1', () => {
        const actual = BigFlo('0.333333333333333333333333333333333333333333333333333333333333333333').times('3').toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['(77 / 6) * 3 = 38.5', () => {
        const actual = BigFlo(77).div(6).times(3).toString();
        const expect = '38.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['4.5 * 0 = 0', () => {
        const actual = BigFlo('4.5').times('0').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-3.2 * 0 = 0', () => {
        const actual = BigFlo('-3.2').times('0').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-2.5 + -3.5 = -6', () => {
        const actual = BigFlo('-2.5').plus('-3.5').toString();
        const expect = '-6';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-4.1 - 2.1 = -6.2', () => {
        const actual = BigFlo('-4.1').minus('2.1').toString();
        const expect = '-6.2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1e+30 + 1e+30 = 2e+30', () => {
        const actual = BigFlo('1e+30').plus('1e+30').toString();
        const expect = '2000000000000000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1e+30 + 0.0000000001 = 1e+30', () => {
        const actual = BigFlo('1e+30').plus('0.0000000001').toString();
        const expect = '1000000000000000000000000000000.0000000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['"abc" + 5 = NaN', () => {
        const actual = BigFlo('abc').plus('5').toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1e+308 * 1e+308 = Infinity', () => {
        const actual = BigFlo('1e+308').times('1e+308').toString();
        const expect = '10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1e-20 + -1e-20 = 0', () => {
        const actual = BigFlo('1e-20').plus('-1e-20').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1e-20 + 1e-20 = 0', () => {
        const actual = BigFlo('-1e-20').plus('1e-20').toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['123456789.987654321 + 987654321.123456789 = 1111111111.11111111', () => {
        const actual = BigFlo('123456789.987654321').plus('987654321.123456789').toString();
        const expect = '1111111111.11111111';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1234.5678 * 8765.4321 = 10821520.22374638', () => {
        const actual = BigFlo('1234.5678').times('8765.4321').toString();
        const expect = '10821520.22374638';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1000000 / 3 = 333333.33333333333333', () => {
        const actual = BigFlo('1000000').div('3').toString();
        const expect = '333333.333333333333333333333333333333333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1e-20 / 2 = 5e-21', () => {
        const actual = BigFlo('1e-20').div('2').toString();
        const expect = '0.000000000000000000005';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1e+20 + 1e-20 = 100000000000000000000', () => {
        const actual = BigFlo('1e+20').plus('1e-20').toString();
        const expect = '100000000000000000000.00000000000000000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['((10.5 + 2.3) * 4.1) / 5.2 = 10.092307692307692', () => {
        const actual = BigFlo('10.5').plus('2.3').times('4.1').div('5.2').toString();
        const expect = '10.092307692307692307692307692307692';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-15.75 + 20.85 = 5.1', () => {
        const actual = BigFlo('-15.75').plus('20.85').toString();
        const expect = '5.1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['MANUAL: (40 / 1) ^ 18', () => {
        const actual = BigFlo(40).div(1).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).times(40).toString();
        const expect = '68719476736000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['POW: (40 / 1) ^ 18', () => {
        const actual = BigFlo(40).div(1).pow(18).toString();
        const expect = '68719476736000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Math.pow(5.65685424949238, 0) = 1', () => {
        const actual = BigFlo(5.65685424949238).pow(0).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Math.pow(5.65685424949238, 1) = 5.65685424949238', () => {
        const actual = BigFlo(5.65685424949238).pow(1).toString();
        const expect = '5.65685424949238';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Math.pow(5.65685424949238, 7) = 185363.8000473662', () => {
        const actual = BigFlo(5.65685424949238).pow(7).toString();
        const expect = '185363.80004736626946079033324232335603915663809104542652073073276109355066551181403821697851805615352192';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Math.pow(5.65685424949238, 18) = 35184372088831.945', () => {
        const actual = BigFlo(5.65685424949238).pow(18).toString();
        // const expect = '35184372088831.945';

        // WOLFRAM (WRONG ANSWER)
        // const expect = '3.5184372088831978145435197507121869870426705698655780193239249483935807403435382104689929184504409359869186850841822700602404615906993535448455233249089697086507418550705756921909267129778787833636002449660646747499685608643574691484745238517515328868540770429435904e13';
        
        const expect = '35184372088831.978145435197507121869870426705698655780193239249483935807403435382104689929184504409359869186850841822700602404615906993535448455233249089697086507418550705756921909267129778787833636002449660646747499685608643574691484745238517515328868540770429435904';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Math.pow(-10, 3) = -1000', () => {
        const actual = BigFlo(-10).pow(3).toString();
        const expect = '-1000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Math.pow(-10, 4) = 10000', () => {
        const actual = BigFlo(-10).pow(4).toString();
        const expect = '10000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Math.pow(-10, 600) = Infinity', () => {
        const actual = BigFlo(-10).pow(600).toString();
        const expect = '1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.1 ** 10 = 1.0000000000000006e-10', () => {
        const actual = BigFlo(0.1).pow(10).toString();
        const expect = '0.0000000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Number("123"); // 123', () => {
        const actual = +BigFlo('123');
        const expect = 123;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Number("123") === 123; // true', () => {
        const actual = +BigFlo("123") === 123;
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Number("12.3"); // 12.3', () => {
        const actual = +BigFlo('12.3');
        const expect = 12.3;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Number("12.00"); // 12', () => {
        const actual = +BigFlo('12.00');
        const expect = 12;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Number("123e-1"); // 12.3', () => {
        const actual = +BigFlo('123e-1');
        const expect = 12.3;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Number("foo"); // NaN', () => {
        const actual = +BigFlo('foo');
        const expect = NaN;
        const result = isNaN(actual);
        return { result, expect, actual };
    }],

    ['Number("100a"); // NaN', () => {
        const actual = +BigFlo('100a');
        const expect = NaN;
        const result = isNaN(actual);
        return { result, expect, actual };
    }],

    ['Number("-Infinity"); // -Infinity', () => {
        const actual = +BigFlo('-Infinity');
        const expect = -Infinity;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 / 12 = -0.08333333333333333', () => {
        const actual = BigFlo('-1').div(12).toString();
        const expect = '-0.083333333333333333333333333333333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 / -12 = -0.08333333333333333', () => {
        const actual = BigFlo(1).div(-12).toString();
        const expect = '-0.083333333333333333333333333333333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['123456789123456789 + 987654321987654321 = 1111111111111111110', () => {
        const actual = BigFlo('123456789123456789').plus('987654321987654321').toString();
        const expect = '1111111111111111110';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.000123 - 0.000456 = -0.000333', () => {
        const actual = BigFlo(0.000123).minus(0.000456).toString();
        const expect = '-0.000333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['987654321 * 123456789 = 121932631112635269', () => {
        const actual = BigFlo('987654321').times('123456789').toString();
        const expect = '121932631112635269';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1000000000000000000 - 1 = 999999999999999999', () => {
        const actual = BigFlo('1000000000000000000').minus(1).toString();
        const expect = '999999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-123456789123456789 * 2 = -246913578246913578', () => {
        const actual = BigFlo('-123456789123456789').times(2).toString();
        const expect = '-246913578246913578';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.1 / 0.02 = 5', () => {
        const actual = BigFlo(0.1).div(0.02).toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 / -123456789012345678901234567890 = -8.1000000729e-30', () => {
        const actual = BigFlo(1).setDivisionPrecision(200).div(-123456789012345678901234567890).toString();
        const expect = '-0.00000000000000000000000000000810000007290000059130000473850003791610030333690242670331941363465530908534247269083978153481825228664601830126814641824517135406137084059096673282773387072187097387496779';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['123456789012345678901234567890 + 987654321098765432109876543210 = 1111111110111111111011111111100', () => {
        const actual = BigFlo('123456789012345678901234567890').plus('987654321098765432109876543210').toString();
        const expect = '1111111110111111111011111111100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.000000000123456789 - 0.000000000987654321 = -0.000000000864197532', () => {
        const actual = BigFlo(0.000000000123456789).minus(0.000000000987654321).toString();
        const expect = '-0.000000000864197532';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['98765432109876543210 * 12345678901234567890 = 1.219326311370218e+39', () => {
        const actual = BigFlo('98765432109876543210').times('12345678901234567890').toString();
        const expect = '1219326311370217952237463801111263526900';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 / 3333333333333333333333333333333333 = 3e-34', () => {
        const actual = BigFlo(1).setDivisionPrecision(200).div(3333333333333333333333333333333333).toString();
        const expect = '0.0000000000000000000000000000000003000000000000000030000000000000000300000000000000003000000000000000030000000000000000300000000000000003000000000000000030000000000000000300000000000000003';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1000000000000000000000000000000000000 - 1 = 999999999999999999999999999999999999', () => {
        const actual = BigFlo('1000000000000000000000000000000000000').minus(1).toString();
        const expect = '999999999999999999999999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.0000000001 + 0.0000000002 = 0.0000000003', () => {
        const actual = BigFlo(0.0000000001).plus(0.0000000002).toString();
        const expect = '0.0000000003';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-123456789012345678901234567890 * 2 = -246913578024691357802469135780', () => {
        const actual = BigFlo('-123456789012345678901234567890').times(2).toString();
        const expect = '-246913578024691357802469135780';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.000000001 / 0.000000002 = 0.5', () => {
        const actual = BigFlo(0.000000001).div(0.000000002).toString();
        const expect = '0.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123 + 9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987', () => {
        const actual = BigFlo('1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').plus('9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').toString();
        const expect = '11111111101111111110111111111011111111101111111110111111111011111111101111111110111111111011111111101110';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987 - 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123 = 8641975320864197532086419753208641975320864197532086419753208641975320864197532086419753208641975320864', () => {
        const actual = BigFlo('9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').minus('1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').toString();
        const expect = '8641975320864197532086419753208641975320864197532086419753208641975320864197532086419753208641975320864';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123 * 2 = 2469135780246913578024691357802469135780246913578024691357802469135780246913578024691357802469135780246', () => {
        const actual = BigFlo('1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').times(2).toString();
        const expect = '2469135780246913578024691357802469135780246913578024691357802469135780246913578024691357802469135780246';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123 / 3 = 411522630041152263004115226300411522630041152263004115226300411522630041152263004115226300411522630041', () => {
        const actual = BigFlo('1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').div(3).toString();
        const expect = '411522630041152263004115226300411522630041152263004115226300411522630041152263004115226300411522630041';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987 + 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123 = -8641975320864197532086419753208641975320864197532086419753208641975320864197532086419753208641975320864', () => {
        const actual = BigFlo('-9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').plus('1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').toString();
        const expect = '-8641975320864197532086419753208641975320864197532086419753208641975320864197532086419753208641975320864';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123 / -9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987', () => {
        const actual = BigFlo('1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').setDivisionPrecision(200).div('-9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').toString();
        const expect = '-0.12499999886093750001423828124982202148437722473144528469085693394136428832573294639592833817005089577283639516667412903198560983745556692140236307542783849078283491849989352727331784386215144553980975';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123 - 9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987', () => {
        const actual = BigFlo('-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').minus('9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').toString();
        const expect = '-11111111101111111110111111111011111111101111111110111111111011111111101111111110111111111011111111101110';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987 * -2 = -19753086421975308642197530864219753086421975308642197530864219753086421975308642197530864219753086421974', () => {
        const actual = BigFlo('9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').times(-2).toString();
        const expect = '-19753086421975308642197530864219753086421975308642197530864219753086421975308642197530864219753086421974';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['12345678901234567890123456789012345678901234567.89012345678901234567890123456789012345678901234567890123 * -98765432109876.54321098765432109876543210987654321098765432109876543210987654321098765432109876543210987', () => {
        const actual = BigFlo('12345678901234567890123456789012345678901234567.89012345678901234567890123456789012345678901234567890123').times('-98765432109876.54321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').toString();
        const expect = '-1219326311370217952261850327338667885945115073915636335923676.1164455788599298790108215200135650052126042539123615968591236768327011193979489871112627862282730673745419856126256664487797134336296860222381401';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987 / 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123', () => {
        const actual = BigFlo('9876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987').setDivisionPrecision(200).div('1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123').toString();
        const expect = '8.00000007290000066339000603684905493532639991147023919437917666885050768653961994751054152234592785335037345822512840448142488593904974898391062689446369612160025628258598851334776818198367212177414946';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123).isFinite()', () => {
        const actual = BigFlo(123).isFinite();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).isFinite()', () => {
        const actual = BigFlo(Infinity).isFinite();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],


    ['BigFlo(-Infinity).isFinite()', () => {
        const actual = BigFlo(-Infinity).isFinite();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(NaN).isFinite()', () => {
        const actual = BigFlo(NaN).isFinite();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isFinite()', () => {
        const actual = BigFlo(0).isFinite();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(42).isInteger()', () => {
        const actual = BigFlo(42).isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(42.3).isInteger()', () => {
        const actual = BigFlo(42.3).isInteger();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("100").isInteger()', () => {
        const actual = BigFlo("100").isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-1).isInteger()', () => {
        const actual = BigFlo(-1).isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isInteger()', () => {
        const actual = BigFlo(0).isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(NaN).isNaN()', () => {
        const actual = BigFlo(NaN).isNaN();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).isNaN()', () => {
        const actual = BigFlo(5).isNaN();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(3.14).isNaN()', () => {
        const actual = BigFlo(3.14).isNaN();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("not-a-number").isNaN()', () => {
        const actual = BigFlo("not-a-number").isNaN();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).isNaN()', () => {
        const actual = BigFlo(Infinity).isNaN();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123456789).isSafeInteger()', () => {
        const actual = BigFlo(123456789).isSafeInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Number.MAX_SAFE_INTEGER + 1).isSafeInteger()', () => {
        const actual = BigFlo(Number.MAX_SAFE_INTEGER + 1).isSafeInteger();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(3.14).isSafeInteger()', () => {
        const actual = BigFlo(3.14).isSafeInteger();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("9007199254740993").isSafeInteger()', () => {
        const actual = BigFlo("9007199254740993").isSafeInteger();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isSafeInteger()', () => {
        const actual = BigFlo(0).isSafeInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(42).parseInt()', () => {
        const actual = BigFlo(42).parseInt();
        const expect = 42;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(42.99).parseInt()', () => {
        const actual = BigFlo(42.99).parseInt();
        const expect = 42;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-123).parseInt()', () => {
        const actual = BigFlo(-123).parseInt();
        const expect = -123;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("9007199254740991").parseInt()', () => {
        const actual = BigFlo("9007199254740991").parseInt();
        const expect = 9007199254740991;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("42").parseInt()', () => {
        const actual = BigFlo("42").parseInt();
        const expect = 42;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("123abc").parseInt()', () => {
        const actual = BigFlo("123abc").parseInt().toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0x1A").parseInt()', () => {
        const actual = BigFlo("0x1A").parseInt().toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1e3").parseInt()', () => {
        const actual = BigFlo("1e3").parseInt();
        const expect = 1000;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).parseInt()', () => {
        const actual = BigFlo(0).parseInt();
        const expect = 0;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-123.45).parseInt()', () => {
        const actual = BigFlo(-123.45).parseInt();
        const expect = -123;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("9007199254740993").parseBigInt()', () => {
        const actual = BigFlo("9007199254740993").parseBigInt();
        const expect = 9007199254740993n;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("123456789012345678901234567890").parseBigInt()', () => {
        const actual = BigFlo("123456789012345678901234567890").parseBigInt();
        const expect = 123456789012345678901234567890n;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123.456).parseBigInt()', () => {
        const actual = BigFlo(123.456).parseBigInt();
        const expect = 123n;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-123456789).parseBigInt()', () => {
        const actual = BigFlo(-123456789).parseBigInt();
        const expect = -123456789n;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123.456).parseFloat()', () => {
        const actual = BigFlo(123.456).parseFloat();
        const expect = 123.456;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("12345678901234567890.123456789").parseFloat()', () => {
        const actual = BigFlo("12345678901234567890.123456789").parseFloat();
        const expect = 12345678901234567000;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1e-3").parseFloat()', () => {
        const actual = BigFlo("1e-3").parseFloat();
        const expect = 0.001;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-123.456).parseFloat()', () => {
        const actual = BigFlo(-123.456).parseFloat();
        const expect = -123.456;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("102.3abc").parseFloat()', () => {
        const actual = BigFlo("102.3abc").parseFloat().toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).parseFloat()', () => {
        const actual = BigFlo(Infinity).parseFloat();
        const expect = Infinity;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123.456).toFixed(2)', () => {
        const actual = BigFlo(123.456).toFixed(2);
        const expect = "123.45";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123.456).toFixed()', () => {
        const actual = BigFlo(123.456).toFixed();
        const expect = "123";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("12345678901234567890.123456").toFixed(3)', () => {
        const actual = BigFlo("12345678901234567890.123456").toFixed(3);
        const expect = "12345678901234567890.123";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-123.456).toFixed(2)', () => {
        const actual = BigFlo(-123.456).toFixed(2);
        const expect = "-123.45";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123.456789).toFixed(50)', () => {
        const actual = BigFlo(123.456789).toFixed(50);
        const expect = "123.45678900000000000000000000000000000000000000000000";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).toFixed(2)', () => {
        const actual = BigFlo(Infinity).toFixed(2);
        const expect = "Infinity";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-Infinity).toFixed(2)', () => {
        const actual = BigFlo(-Infinity).toFixed(2);
        const expect = "-Infinity";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(NaN).toFixed(2)', () => {
        const actual = BigFlo(NaN).toFixed(2);
        const expect = "NaN";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123).abs()', () => {
        const actual = BigFlo(123).abs().toString();
        const expect = '123';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-123).abs()', () => {
        const actual = BigFlo(-123).abs().toString();
        const expect = '123';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).abs()', () => {
        const actual = BigFlo(0).abs().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("12345678901234567890").abs()', () => {
        const actual = BigFlo("12345678901234567890").abs().toString();
        const expect = '12345678901234567890';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-123.456).abs()', () => {
        const actual = BigFlo(-123.456).abs().toString();
        const expect = '123.456';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-123456789012345678901234567890").abs()', () => {
        const actual = BigFlo("-123456789012345678901234567890").abs().toString();
        const expect = '123456789012345678901234567890';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.000001).abs()', () => {
        const actual = BigFlo(0.000001).abs().toString();
        const expect = '0.000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-0.1234567890123456789").abs()', () => {
        const actual = BigFlo('-0.1234567890123456789').abs().toString();
        const expect = '0.1234567890123456789';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-123").abs()', () => {
        const actual = BigFlo("-123").abs().toString();
        const expect = '123';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-1e3").abs()', () => {
        const actual = BigFlo("-1e3").abs().toString();
        const expect = '1000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-Infinity).ceil()', () => {
        const actual = BigFlo(-Infinity).ceil().toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-7.004).ceil()', () => {
        const actual = BigFlo(-7.004).ceil().toString();
        const expect = '-7';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-4).ceil()', () => {
        const actual = BigFlo(-4).ceil().toString();
        const expect = '-4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.95).ceil()', () => {
        const actual = BigFlo(-0.95).ceil().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0).ceil()', () => {
        const actual = BigFlo(-0).ceil().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).ceil()', () => {
        const actual = BigFlo(0).ceil().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.95).ceil()', () => {
        const actual = BigFlo(0.95).ceil().toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(4).ceil()', () => {
        const actual = BigFlo(4).ceil().toString();
        const expect = '4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(7.004).ceil()', () => {
        const actual = BigFlo(7.004).ceil().toString();
        const expect = '8';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).ceil()', () => {
        const actual = BigFlo(Infinity).ceil().toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-Infinity).floor()', () => {
        const actual = BigFlo(-Infinity).floor().toString();
        const expect = "-Infinity";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-45.95).floor()', () => {
        const actual = BigFlo(-45.95).floor().toString();
        const expect = "-46";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-45.05).floor()', () => {
        const actual = BigFlo(-45.05).floor().toString();
        const expect = "-46";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0).floor()', () => {
        const actual = BigFlo(-0).floor().toString();
        const expect = "0";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).floor()', () => {
        const actual = BigFlo(0).floor().toString();
        const expect = "0";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(4).floor()', () => {
        const actual = BigFlo(4).floor().toString();
        const expect = "4";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(45.05).floor()', () => {
        const actual = BigFlo(45.05).floor().toString();
        const expect = "45";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(45.95).floor()', () => {
        const actual = BigFlo(45.95).floor().toString();
        const expect = "45";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).floor()', () => {
        const actual = BigFlo(Infinity).floor().toString();
        const expect = "Infinity";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(7.004).floor()', () => {
        const actual = BigFlo(7.004).floor().toString();
        const expect = '7';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-7.004).floor()', () => {
        const actual = BigFlo(-7.004).floor().toString();
        const expect = '-8';
        const result = actual === expect;
        return { result, expect, actual };
    }],


    ['BigFlo(-Infinity).round()', () => {
        const actual = BigFlo(-Infinity).round().toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-20.51).round()', () => {
        const actual = BigFlo(-20.51).round().toString();
        const expect = '-21';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-20.5).round()', () => {
        const actual = BigFlo(-20.5).round().toString();
        const expect = '-20';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.1).round()', () => {
        const actual = BigFlo(-0.1).round().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).round()', () => {
        const actual = BigFlo(0).round().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(20.49).round()', () => {
        const actual = BigFlo(20.49).round().toString();
        const expect = '20';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(20.5).round()', () => {
        const actual = BigFlo(20.5).round().toString();
        const expect = '21';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(42).round()', () => {
        const actual = BigFlo(42).round().toString();
        const expect = '42';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).round()', () => {
        const actual = BigFlo(Infinity).round().toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(3).sign()', () => {
        const actual = BigFlo(3).sign().toString();
        const expect = "1";
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-3).sign()', () => {
        const actual = BigFlo(-3).sign().toString();
        const expect = "-1";
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo("-3").sign()', () => {
        const actual = BigFlo("-3").sign().toString();
        const expect = "-1";
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(0).sign()', () => {
        const actual = BigFlo(0).sign().toString();
        const expect = "0";
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-0).sign()', () => {
        const actual = BigFlo(-0).sign().toString();
        const expect = "0";
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(NaN).sign()', () => {
        const actual = BigFlo(NaN).sign().toString();
        const expect = "NaN";
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo("foo").sign()', () => {
        const actual = BigFlo("foo").sign().toString();
        const expect = "NaN";
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo().sign()', () => {
        const actual = BigFlo().sign().toString();
        const expect = "NaN";
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).isEqual(5)', () => {
        const actual = BigFlo(5).isEqual(5);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(5).isEqual(4)', () => {
        const actual = BigFlo(5).isEqual(4);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-1).isEqual(-1)', () => {
        const actual = BigFlo(-1).isEqual(-1);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(0).isEqual(0)', () => {
        const actual = BigFlo(0).isEqual(0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(3.14).isEqual(2.71)', () => {
        const actual = BigFlo(3.14).isEqual(2.71);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0).eq(0)", () => {
        const actual = BigFlo(0).eq(0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14).eq(2.71)", () => {
        const actual = BigFlo(3.14).eq(2.71);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0)['=='](0)", () => {
        const actual = BigFlo(0)['=='](0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14)['=='](2.71)", () => {
        const actual = BigFlo(3.14)['=='](2.71);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).isGreaterThan(4)', () => {
        const actual = BigFlo(5).isGreaterThan(4);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(5).isGreaterThan(5)', () => {
        const actual = BigFlo(5).isGreaterThan(5);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-1).isGreaterThan(-2)', () => {
        const actual = BigFlo(-1).isGreaterThan(-2);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(0).isGreaterThan(1)', () => {
        const actual = BigFlo(0).isGreaterThan(1);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(3.14).isGreaterThan(3)', () => {
        const actual = BigFlo(3.14).isGreaterThan(3);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0).gt(1)", () => {
        const actual = BigFlo(0).gt(1);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14).gt(3)", () => {
        const actual = BigFlo(3.14).gt(3);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0)['>'](1)", () => {
        const actual = BigFlo(0)['>'](1);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14)['>'](3)", () => {
        const actual = BigFlo(3.14)['>'](3);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(4).isLessThan(5)', () => {
        const actual = BigFlo(4).isLessThan(5);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(6).isLessThan(5)', () => {
        const actual = BigFlo(6).isLessThan(5);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-2).isLessThan(-1)', () => {
        const actual = BigFlo(-2).isLessThan(-1);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-1).isLessThan(-1)', () => {
        const actual = BigFlo(-1).isLessThan(-1);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(3.139).isLessThan(3.14)', () => {
        const actual = BigFlo(3.139).isLessThan(3.14);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(-1).lt(-1)", () => {
        const actual = BigFlo(-1).lt(-1);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.139).lt(3.14)", () => {
        const actual = BigFlo(3.139).lt(3.14);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(-1)['<'](-1)", () => {
        const actual = BigFlo(-1)['<'](-1);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.139)['<'](3.14)", () => {
        const actual = BigFlo(3.139)['<'](3.14);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).isGreaterThanOrEqual(5)', () => {
        const actual = BigFlo(5).isGreaterThanOrEqual(5);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(5).isGreaterThanOrEqual(6)', () => {
        const actual = BigFlo(5).isGreaterThanOrEqual(6);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-1).isGreaterThanOrEqual(-2)', () => {
        const actual = BigFlo(-1).isGreaterThanOrEqual(-2);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(0).isGreaterThanOrEqual(0)', () => {
        const actual = BigFlo(0).isGreaterThanOrEqual(0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(3.14).isGreaterThanOrEqual(3.15)', () => {
        const actual = BigFlo(3.14).isGreaterThanOrEqual(3.15);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0).gte(0)", () => {
        const actual = BigFlo(0).gte(0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14).gte(3.15)", () => {
        const actual = BigFlo(3.14).gte(3.15);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0)['>='](0)", () => {
        const actual = BigFlo(0)['>='](0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14)['>='](3.15)", () => {
        const actual = BigFlo(3.14)['>='](3.15);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(4).isLessThanOrEqual(5)', () => {
        const actual = BigFlo(4).isLessThanOrEqual(5);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(5).isLessThanOrEqual(4)', () => {
        const actual = BigFlo(5).isLessThanOrEqual(4);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-2).isLessThanOrEqual(-1)', () => {
        const actual = BigFlo(-2).isLessThanOrEqual(-1);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(0).isLessThanOrEqual(0)', () => {
        const actual = BigFlo(0).isLessThanOrEqual(0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(3.139).isLessThanOrEqual(3.138)', () => {
        const actual = BigFlo(3.139).isLessThanOrEqual(3.138);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0).lte(0)", () => {
        const actual = BigFlo(0).lte(0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.139).lte(3.138)", () => {
        const actual = BigFlo(3.139).lte(3.138);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0)['<='](0)", () => {
        const actual = BigFlo(0)['<='](0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.139)['<='](3.138)", () => {
        const actual = BigFlo(3.139)['<='](3.138);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).isDifferent(4)', () => {
        const actual = BigFlo(5).isDifferent(4);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(5).isDifferent(5)', () => {
        const actual = BigFlo(5).isDifferent(5);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(-1).isDifferent(-2)', () => {
        const actual = BigFlo(-1).isDifferent(-2);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(0).isDifferent(-0)', () => {
        const actual = BigFlo(0).isDifferent(-0);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ['BigFlo(3.14).isDifferent(3.14)', () => {
        const actual = BigFlo(3.14).isDifferent(3.14);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0).neq(-0)", () => {
        const actual = BigFlo(0).neq(-0);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14).neq(3.14)", () => {
        const actual = BigFlo(3.14).neq(3.14);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(0)['!='](-0)", () => {
        const actual = BigFlo(0)['!='](-0);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["BigFlo(3.14)['!='](3.14)", () => {
        const actual = BigFlo(3.14)['!='](3.14);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],
    
    ["Planck volume count in the whole observable universe", () => {
        const PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679';
        const planckLength = BigFlo('1.616255e-35');
        const planckVolume = planckLength['**'](3);
        const sphereVolume = r => BigFlo(4).setDivisionPrecision(100)['/'](3)['*'](PI)['*'](BigFlo(r)['**'](3));
        const observableUniverseDiameter = BigFlo('8.8e26');
        const observableUniverseRadius = observableUniverseDiameter['/'](2);
        const observableUniverseVolume = sphereVolume(observableUniverseRadius);
        const planckVolumeCountInObservableUniverse = observableUniverseVolume['/'](planckVolume).floor();

        const actual = planckVolumeCountInObservableUniverse.toString();
        const expect = '84511730484834131206881865680639113619647108892011465350695564305272555636684111446309955229141533316023379319781575896906672933616475618801242275287976816735193410571088873930085447368';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // heads up:
    // - no base convertion from strings (binary, hex, octal)
    // - empty strings and null are NaN instead of zero
    // - only toThePowerOf integers

    // ========================================
    // NEW TESTS — isNegative / isPositive
    // ========================================

    ['BigFlo(5).isNegative()', () => {
        const actual = BigFlo(5).isNegative();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-5).isNegative()', () => {
        const actual = BigFlo(-5).isNegative();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isNegative()', () => {
        const actual = BigFlo(0).isNegative();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0).isNegative()', () => {
        const actual = BigFlo(-0).isNegative();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-3.14").isNegative()', () => {
        const actual = BigFlo("-3.14").isNegative();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).isNegative()', () => {
        const actual = BigFlo(Infinity).isNegative();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-Infinity).isNegative()', () => {
        const actual = BigFlo(-Infinity).isNegative();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).isPositive()', () => {
        const actual = BigFlo(5).isPositive();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-5).isPositive()', () => {
        const actual = BigFlo(-5).isPositive();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isPositive()', () => {
        const actual = BigFlo(0).isPositive();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-0.001").isPositive()', () => {
        const actual = BigFlo("-0.001").isPositive();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.001").isPositive()', () => {
        const actual = BigFlo("0.001").isPositive();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — trunc()
    // ========================================

    ['BigFlo(42.7).trunc()', () => {
        const actual = BigFlo(42.7).trunc().toString();
        const expect = '42';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-42.7).trunc()', () => {
        const actual = BigFlo(-42.7).trunc().toString();
        const expect = '-42';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.99).trunc()', () => {
        const actual = BigFlo(0.99).trunc().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.99).trunc()', () => {
        const actual = BigFlo(-0.99).trunc().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(100).trunc()', () => {
        const actual = BigFlo(100).trunc().toString();
        const expect = '100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-100).trunc()', () => {
        const actual = BigFlo(-100).trunc().toString();
        const expect = '-100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).trunc()', () => {
        const actual = BigFlo(0).trunc().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("123456789.987654321").trunc()', () => {
        const actual = BigFlo("123456789.987654321").trunc().toString();
        const expect = '123456789';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-0.0000001").trunc()', () => {
        const actual = BigFlo("-0.0000001").trunc().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).trunc()', () => {
        const actual = BigFlo(Infinity).trunc().toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-Infinity).trunc()', () => {
        const actual = BigFlo(-Infinity).trunc().toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(NaN).trunc()', () => {
        const actual = BigFlo(NaN).trunc().toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — toJSON()
    // ========================================

    ['BigFlo(123.456).toJSON()', () => {
        const actual = BigFlo(123.456).toJSON();
        const expect = '123.456';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-99.99).toJSON()', () => {
        const actual = BigFlo(-99.99).toJSON();
        const expect = '-99.99';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).toJSON()', () => {
        const actual = BigFlo(0).toJSON();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['JSON.stringify(BigFlo(42.5))', () => {
        const actual = JSON.stringify(BigFlo(42.5));
        const expect = '"42.5"';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['JSON.stringify({ value: BigFlo("123.456") })', () => {
        const actual = JSON.stringify({ value: BigFlo("123.456") });
        const expect = '{"value":"123.456"}';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['JSON.stringify([BigFlo(1), BigFlo(2.5), BigFlo(-3)])', () => {
        const actual = JSON.stringify([BigFlo(1), BigFlo(2.5), BigFlo(-3)]);
        const expect = '["1","2.5","-3"]';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — toString() dedicated
    // ========================================

    ['BigFlo(0).toString()', () => {
        const actual = BigFlo(0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0).toString()', () => {
        const actual = BigFlo(-0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.00000").toString()', () => {
        const actual = BigFlo("0.00000").toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("100.000").toString()', () => {
        const actual = BigFlo("100.000").toString();
        const expect = '100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.10").toString()', () => {
        const actual = BigFlo("0.10").toString();
        const expect = '0.1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(NaN).toString()', () => {
        const actual = BigFlo(NaN).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(Infinity).toString()', () => {
        const actual = BigFlo(Infinity).toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-Infinity).toString()', () => {
        const actual = BigFlo(-Infinity).toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Constructor edge cases & input types
    // ========================================

    ['BigFlo(0n).toString()', () => {
        const actual = BigFlo(0n).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-42n).toString()', () => {
        const actual = BigFlo(-42n).toString();
        const expect = '-42';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123456789012345678901234567890n).toString()', () => {
        const actual = BigFlo(123456789012345678901234567890n).toString();
        const expect = '123456789012345678901234567890';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(BigInt("99999999999999999999")).toString()', () => {
        const actual = BigFlo(BigInt("99999999999999999999")).toString();
        const expect = '99999999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(BigFlo(42)).toString()', () => {
        const actual = BigFlo(BigFlo(42)).toString();
        const expect = '42';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(BigFlo("-3.14")).toString()', () => {
        const actual = BigFlo(BigFlo("-3.14")).toString();
        const expect = '-3.14';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(BigFlo("1e10")).toString()', () => {
        const actual = BigFlo(BigFlo("1e10")).toString();
        const expect = '10000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("").toString()', () => {
        const actual = BigFlo("").toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(null).toString()', () => {
        const actual = BigFlo(null).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(undefined).toString()', () => {
        const actual = BigFlo(undefined).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(true).toString()', () => {
        const actual = BigFlo(true).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(false).toString()', () => {
        const actual = BigFlo(false).toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(" 42 ").toString()', () => {
        const actual = BigFlo(" 42 ").toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("--5").toString()', () => {
        const actual = BigFlo("--5").toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.2.3").toString()', () => {
        const actual = BigFlo("1.2.3").toString();
        const expect = 'NaN';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Input type mixing
    // ========================================

    ['BigFlo("10").plus(5)', () => {
        const actual = BigFlo("10").plus(5).toString();
        const expect = '15';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(10).plus("5")', () => {
        const actual = BigFlo(10).plus("5").toString();
        const expect = '15';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(10n).plus("5.5")', () => {
        const actual = BigFlo(10n).plus("5.5").toString();
        const expect = '15.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("10.5").minus(3n)', () => {
        const actual = BigFlo("10.5").minus(3n).toString();
        const expect = '7.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(10).times(BigFlo(3))', () => {
        const actual = BigFlo(10).times(BigFlo(3)).toString();
        const expect = '30';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("7.5").div(BigFlo("2.5"))', () => {
        const actual = BigFlo("7.5").div(BigFlo("2.5")).toString();
        const expect = '3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(100n).minus(0.5)', () => {
        const actual = BigFlo(100n).minus(0.5).toString();
        const expect = '99.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1e3").plus(500)', () => {
        const actual = BigFlo("1e3").plus(500).toString();
        const expect = '1500';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("5e-2").times("200")', () => {
        const actual = BigFlo("5e-2").times("200").toString();
        const expect = '10';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Negative zero edge cases
    // ========================================

    ['0 - 0 = 0 (not -0)', () => {
        const actual = BigFlo(0).minus(0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-0 + 0 = 0', () => {
        const actual = BigFlo(-0).plus(0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-0 - 0 = 0', () => {
        const actual = BigFlo(-0).minus(0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-0 * 5 = 0', () => {
        const actual = BigFlo(-0).times(5).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-0 * -5 = 0', () => {
        const actual = BigFlo(-0).times(-5).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isEqual(-0)', () => {
        const actual = BigFlo(0).isEqual(-0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0).isEqual(0)', () => {
        const actual = BigFlo(-0).isEqual(0);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — 0/0 and Infinity edge cases
    // ========================================

    ['0 / 0 = Infinity', () => {
        const actual = BigFlo(0).div(0).toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity * 0 = 0', () => {
        const actual = BigFlo(Infinity).times(0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0 * Infinity = 0', () => {
        const actual = BigFlo(0).times(Infinity).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0 * -Infinity = 0', () => {
        const actual = BigFlo(0).times(-Infinity).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity * 0 = 0', () => {
        const actual = BigFlo(-Infinity).times(0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Infinity - Infinity = 0', () => {
        const actual = BigFlo(Infinity).minus(Infinity).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity + Infinity = 0', () => {
        const actual = BigFlo(-Infinity).plus(Infinity).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity / Infinity = -Infinity', () => {
        const actual = BigFlo(-Infinity).div(Infinity).toString();
        const expect = '-Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-Infinity / -Infinity = Infinity', () => {
        const actual = BigFlo(-Infinity).div(-Infinity).toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Additional exponentiation
    // ========================================

    ['BigFlo(2).pow(10)', () => {
        const actual = BigFlo(2).pow(10).toString();
        const expect = '1024';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(2).pow(20)', () => {
        const actual = BigFlo(2).pow(20).toString();
        const expect = '1048576';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(2).pow(50)', () => {
        const actual = BigFlo(2).pow(50).toString();
        const expect = '1125899906842624';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(2).pow(100)', () => {
        const actual = BigFlo(2).pow(100).toString();
        const expect = '1267650600228229401496703205376';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(3).pow(20)', () => {
        const actual = BigFlo(3).pow(20).toString();
        const expect = '3486784401';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(1).pow(1000)', () => {
        const actual = BigFlo(1).pow(1000).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-2).pow(10)', () => {
        const actual = BigFlo(-2).pow(10).toString();
        const expect = '1024';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-2).pow(11)', () => {
        const actual = BigFlo(-2).pow(11).toString();
        const expect = '-2048';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.1").pow(10)', () => {
        const actual = BigFlo("1.1").pow(10).toString();
        const expect = '2.5937424601';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.5").pow(10)', () => {
        const actual = BigFlo("0.5").pow(10).toString();
        const expect = '0.0009765625';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(99).pow(2)', () => {
        const actual = BigFlo(99).pow(2).toString();
        const expect = '9801';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(10).pow(0)', () => {
        const actual = BigFlo(10).pow(0).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(10).pow(1)', () => {
        const actual = BigFlo(10).pow(1).toString();
        const expect = '10';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Additional subtraction
    // ========================================

    ['0 - 1 = -1', () => {
        const actual = BigFlo(0).minus(1).toString();
        const expect = '-1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 - 0 = 1', () => {
        const actual = BigFlo(1).minus(0).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-5 - -3 = -2', () => {
        const actual = BigFlo(-5).minus(-3).toString();
        const expect = '-2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-3 - -5 = 2', () => {
        const actual = BigFlo(-3).minus(-5).toString();
        const expect = '2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.001 - 0.001 = 0', () => {
        const actual = BigFlo("0.001").minus("0.001").toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['1 - 0.9999999999 = 0.0000000001', () => {
        const actual = BigFlo("1").minus("0.9999999999").toString();
        const expect = '0.0000000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['100 - 100.01 = -0.01', () => {
        const actual = BigFlo("100").minus("100.01").toString();
        const expect = '-0.01';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Additional addition
    // ========================================

    ['0 + 0 = 0', () => {
        const actual = BigFlo(0).plus(0).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-5 + -3 = -8', () => {
        const actual = BigFlo(-5).plus(-3).toString();
        const expect = '-8';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999999999999 + 1 = 1000000000000', () => {
        const actual = BigFlo("999999999999").plus("1").toString();
        const expect = '1000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 + 1 = 0', () => {
        const actual = BigFlo(-1).plus(1).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.0001 + 0.0001 = 0.0002', () => {
        const actual = BigFlo("0.0001").plus("0.0001").toString();
        const expect = '0.0002';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999999999.999 + 0.001 = 1000000000', () => {
        const actual = BigFlo("999999999.999").plus("0.001").toString();
        const expect = '1000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Additional multiplication
    // ========================================

    ['1 * 1 = 1', () => {
        const actual = BigFlo(1).times(1).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 * -1 = 1', () => {
        const actual = BigFlo(-1).times(-1).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 * 1 = -1', () => {
        const actual = BigFlo(-1).times(1).toString();
        const expect = '-1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.001 * 0.001 = 0.000001', () => {
        const actual = BigFlo("0.001").times("0.001").toString();
        const expect = '0.000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999 * 1 = 999 (identity)', () => {
        const actual = BigFlo(999).times(1).toString();
        const expect = '999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['999999999 * 999999999', () => {
        const actual = BigFlo("999999999").times("999999999").toString();
        const expect = '999999998000000001';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.1 * 10 = 1', () => {
        const actual = BigFlo("0.1").times("10").toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.01 * 100 = 1', () => {
        const actual = BigFlo("0.01").times("100").toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Additional division
    // ========================================

    ['1 / 1 = 1', () => {
        const actual = BigFlo(1).div(1).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-1 / -1 = 1', () => {
        const actual = BigFlo(-1).div(-1).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0 / 5 = 0', () => {
        const actual = BigFlo(0).div(5).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['10 / 2 = 5', () => {
        const actual = BigFlo(10).div(2).toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['7 / 2 = 3.5', () => {
        const actual = BigFlo(7).div(2).toString();
        const expect = '3.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['100 / 3 at precision 5', () => {
        const actual = BigFlo(100).setDivisionPrecision(5).div(3).toString();
        const expect = '33.33333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['100 / 3 at precision 50', () => {
        const actual = BigFlo(100).setDivisionPrecision(50).div(3).toString();
        const expect = '33.33333333333333333333333333333333333333333333333333';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-7 / 2 = -3.5', () => {
        const actual = BigFlo(-7).div(2).toString();
        const expect = '-3.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['7 / -2 = -3.5', () => {
        const actual = BigFlo(7).div(-2).toString();
        const expect = '-3.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['0.1 / 10 = 0.01', () => {
        const actual = BigFlo("0.1").div("10").toString();
        const expect = '0.01';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Chaining after Math methods
    // ========================================

    ['BigFlo(-5.7).abs().plus(1)', () => {
        const actual = BigFlo(-5.7).abs().plus(1).toString();
        const expect = '6.7';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5.7).ceil().times(2)', () => {
        const actual = BigFlo(5.7).ceil().times(2).toString();
        const expect = '12';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5.7).floor().times(2)', () => {
        const actual = BigFlo(5.7).floor().times(2).toString();
        const expect = '10';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5.5).round().plus(10)', () => {
        const actual = BigFlo(5.5).round().plus(10).toString();
        const expect = '16';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5.7).trunc().minus(1)', () => {
        const actual = BigFlo(5.7).trunc().minus(1).toString();
        const expect = '4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-3).sign().times(100)', () => {
        const actual = BigFlo(-3).sign().times(100).toString();
        const expect = '-100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-5.7).abs().ceil().plus(1)', () => {
        const actual = BigFlo(-5.7).abs().ceil().plus(1).toString();
        const expect = '7';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(10).plus(5).times(2).minus(10).div(5)', () => {
        const actual = BigFlo(10).plus(5).times(2).minus(10).div(5).toString();
        const expect = '4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Mutability / instance isolation
    // ========================================

    ['Operations mutate the instance (chaining)', () => {
        const a = BigFlo(10);
        a.plus(5);
        const actual = a.toString();
        const expect = '15';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Separate instances do not affect each other', () => {
        const a = BigFlo(10);
        const b = BigFlo(20);
        a.plus(100);
        const actual = b.toString();
        const expect = '20';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['setDivisionPrecision on one instance does not affect another', () => {
        const a = BigFlo(1).setDivisionPrecision(5);
        const b = BigFlo(1);
        const actualA = a.div(3).toString();
        const expectA = '0.33333';
        const actualB = b.div(3).toString();
        const expectB = '0.333333333333333333333333333333333';
        const result = actualA === expectA && actualB === expectB;
        return { result, expect: `${expectA} / ${expectB}`, actual: `${actualA} / ${actualB}` };
    }],

    // ========================================
    // NEW TESTS — getDivisionPrecision / getFractionalRoundingPrecision
    // ========================================

    ['BigFlo().getDivisionPrecision() default is 33', () => {
        const actual = BigFlo().getDivisionPrecision();
        const expect = 33;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo().setDivisionPrecision(100).getDivisionPrecision()', () => {
        const actual = BigFlo().setDivisionPrecision(100).getDivisionPrecision();
        const expect = 100;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo().getFractionalRoundingPrecision() default is 33', () => {
        const actual = BigFlo().getFractionalRoundingPrecision();
        const expect = 33;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo().setFractionalRoundingPrecision(50).getFractionalRoundingPrecision()', () => {
        const actual = BigFlo().setFractionalRoundingPrecision(50).getFractionalRoundingPrecision();
        const expect = 50;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Error handling
    // ========================================

    ['setDivisionPrecision(-1) throws TypeError', () => {
        let actual = false;
        try { BigFlo.setDivisionPrecision(-1); } catch (e) { actual = e instanceof TypeError; }
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['setDivisionPrecision("abc") throws TypeError', () => {
        let actual = false;
        try { BigFlo.setDivisionPrecision("abc"); } catch (e) { actual = e instanceof TypeError; }
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['instance setDivisionPrecision(-5) throws TypeError', () => {
        let actual = false;
        try { BigFlo(1).setDivisionPrecision(-5); } catch (e) { actual = e instanceof TypeError; }
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['setFractionalRoundingPrecision(-1) throws TypeError', () => {
        let actual = false;
        try { BigFlo.setFractionalRoundingPrecision(-1); } catch (e) { actual = e instanceof TypeError; }
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['setFractionalRoundingPrecision("abc") throws TypeError', () => {
        let actual = false;
        try { BigFlo.setFractionalRoundingPrecision("abc"); } catch (e) { actual = e instanceof TypeError; }
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['setDivisionPrecision(0) does not throw', () => {
        let actual = true;
        try { BigFlo.setDivisionPrecision(0); BigFlo.setDivisionPrecision(33); } catch (e) { actual = false; }
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Comparison edge cases
    // ========================================

    ['BigFlo(100).isGreaterThan(99)', () => {
        const actual = BigFlo(100).isGreaterThan(99);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(99).isGreaterThan(100)', () => {
        const actual = BigFlo(99).isGreaterThan(100);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.001").isGreaterThan("1.0001")', () => {
        const actual = BigFlo("1.001").isGreaterThan("1.0001");
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.0001").isLessThan("1.001")', () => {
        const actual = BigFlo("1.0001").isLessThan("1.001");
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-1.5").isLessThan("-1.4")', () => {
        const actual = BigFlo("-1.5").isLessThan("-1.4");
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-1.4").isGreaterThan("-1.5")', () => {
        const actual = BigFlo("-1.4").isGreaterThan("-1.5");
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(1).isGreaterThan(-1000)', () => {
        const actual = BigFlo(1).isGreaterThan(-1000);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-1000).isLessThan(1)', () => {
        const actual = BigFlo(-1000).isLessThan(1);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("99999999999999999999999999999999").isGreaterThan("99999999999999999999999999999998")', () => {
        const actual = BigFlo("99999999999999999999999999999999").isGreaterThan("99999999999999999999999999999998");
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("5").isEqual("5.0")', () => {
        const actual = BigFlo("5").isEqual("5.0");
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("5.00000").isEqual("5")', () => {
        const actual = BigFlo("5.00000").isEqual("5");
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isGreaterThan(-1)', () => {
        const actual = BigFlo(0).isGreaterThan(-1);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isLessThan(1)', () => {
        const actual = BigFlo(0).isLessThan(1);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).isGreaterThan(0)', () => {
        const actual = BigFlo(0).isGreaterThan(0);
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Scientific notation edge cases
    // ========================================

    ['BigFlo("0e0").toString()', () => {
        const actual = BigFlo("0e0").toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1e0").toString()', () => {
        const actual = BigFlo("1e0").toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-5e3").toString()', () => {
        const actual = BigFlo("-5e3").toString();
        const expect = '-5000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.5e1").toString()', () => {
        const actual = BigFlo("1.5e1").toString();
        const expect = '15';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.5e-1").toString()', () => {
        const actual = BigFlo("1.5e-1").toString();
        const expect = '0.15';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("6.022e23").toString()', () => {
        const actual = BigFlo("6.022e23").toString();
        const expect = '602200000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.6e-19").toString()', () => {
        const actual = BigFlo("1.6e-19").toString();
        const expect = '0.00000000000000000016';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Large number stress tests
    // ========================================

    ['1000-digit number + 1', () => {
        const a = '9'.repeat(1000);
        const actual = BigFlo(a).plus(1).toString();
        const expect = '1' + '0'.repeat(1000);
        const result = actual === expect;
        return { result, expect: '1 followed by 1000 zeros', actual: `${actual.length} digits, starts ${actual.slice(0,5)}` };
    }],

    ['1000-digit number - 1', () => {
        const a = '1' + '0'.repeat(1000);
        const actual = BigFlo(a).minus(1).toString();
        const expect = '9'.repeat(1000);
        const result = actual === expect;
        return { result, expect: '1000 nines', actual: `${actual.length} digits` };
    }],

    // ========================================
    // NEW TESTS — Commutativity and identity
    // ========================================

    ['Commutativity: 123.456 + 789.012 === 789.012 + 123.456', () => {
        const a = BigFlo("123.456").plus("789.012").toString();
        const b = BigFlo("789.012").plus("123.456").toString();
        const actual = a === b;
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual: `${a} vs ${b}` };
    }],

    ['Commutativity: 12.34 * 56.78 === 56.78 * 12.34', () => {
        const a = BigFlo("12.34").times("56.78").toString();
        const b = BigFlo("56.78").times("12.34").toString();
        const actual = a === b;
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual: `${a} vs ${b}` };
    }],

    ['Identity: x + 0 === x', () => {
        const actual = BigFlo("123.456").plus(0).toString();
        const expect = '123.456';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Identity: x * 1 === x', () => {
        const actual = BigFlo("123.456").times(1).toString();
        const expect = '123.456';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Inverse: x - x === 0', () => {
        const actual = BigFlo("123.456789").minus("123.456789").toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Inverse: x / x === 1', () => {
        const actual = BigFlo("123.456789").div("123.456789").toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Roundtrip: (x + y) - y === x', () => {
        const actual = BigFlo("42.123").plus("99.877").minus("99.877").toString();
        const expect = '42.123';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['Roundtrip: (x * y) / y === x', () => {
        const actual = BigFlo("42").times("7").div("7").toString();
        const expect = '42';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Fractional rounding disabled
    // ========================================

    // ========================================
    // NEW TESTS — round/ceil/floor edge cases
    // ========================================

    ['BigFlo(0.4999999).round()', () => {
        const actual = BigFlo(0.4999999).round().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.5000001).round()', () => {
        const actual = BigFlo(0.5000001).round().toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.4999999).round()', () => {
        const actual = BigFlo(-0.4999999).round().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.5000001).round()', () => {
        const actual = BigFlo(-0.5000001).round().toString();
        const expect = '-1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.50).round() = -0.5 rounds to 0', () => {
        const actual = BigFlo('-0.50').round().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(99.5).round()', () => {
        const actual = BigFlo(99.5).round().toString();
        const expect = '100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-99.5).round()', () => {
        const actual = BigFlo(-99.5).round().toString();
        const expect = '-99';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-99.51).round()', () => {
        const actual = BigFlo(-99.51).round().toString();
        const expect = '-100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("999999999999999999.5").round()', () => {
        const actual = BigFlo("999999999999999999.5").round().toString();
        const expect = '1000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.001).ceil()', () => {
        const actual = BigFlo(0.001).ceil().toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.001).ceil()', () => {
        const actual = BigFlo(-0.001).ceil().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("999999999999999999.001").ceil()', () => {
        const actual = BigFlo("999999999999999999.001").ceil().toString();
        const expect = '1000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.999).floor()', () => {
        const actual = BigFlo(0.999).floor().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0.001).floor()', () => {
        const actual = BigFlo(-0.001).floor().toString();
        const expect = '-1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("-999999999999999999.001").floor()', () => {
        const actual = BigFlo("-999999999999999999.001").floor().toString();
        const expect = '-1000000000000000000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['setFractionalRoundingPrecision(false) returns this (chainable)', () => {
        const actual = BigFlo('0.333333333333333333333333333333333').setFractionalRoundingPrecision(false).times('3').toString();
        const expect = '0.999999999999999999999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING false: 0.333333333333333333333333333333333 * 3', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(false);
        const actual = BigFlo('0.333333333333333333333333333333333').times('3').toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '0.999999999999999999999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['FRACTIONAL ROUNDING false: 1 / 3 * 3 stays 0.999...', () => {
        const original = BigFlo().getFractionalRoundingPrecision();
        BigFlo.setFractionalRoundingPrecision(false);
        const actual = BigFlo(1).div(3).times(3).toString();
        BigFlo.setFractionalRoundingPrecision(original);
        const expect = '0.999999999999999999999999999999999';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Missing from TEST-PLAN.md
    // ========================================

    ['BigFlo(0).pow(100)', () => {
        const actual = BigFlo(0).pow(100).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-0 / 0 = Infinity', () => {
        const actual = BigFlo(-0).div(0).toString();
        const expect = 'Infinity';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo().setFractionalRoundingPrecision(false).getFractionalRoundingPrecision()', () => {
        const actual = BigFlo().setFractionalRoundingPrecision(false).getFractionalRoundingPrecision();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['500-digit + 500-digit', () => {
        const a = '1' + '2'.repeat(499);
        const b = '3' + '4'.repeat(499);
        const result1 = BigFlo(a).plus(b);
        const sum = result1.toString();
        const roundtrip = BigFlo(sum).minus(b).toString();
        const result = roundtrip === a;
        return { result, expect: a.slice(0, 20) + '...', actual: roundtrip.slice(0, 20) + '...' };
    }],

    ['200-digit * 200-digit produces ~400 digits', () => {
        const a = '1' + '2'.repeat(199);
        const b = '3' + '4'.repeat(199);
        const actual = BigFlo(a).times(b).toString();
        const result = actual.length >= 399 && actual.length <= 401;
        return { result, expect: '~400 digits', actual: `${actual.length} digits` };
    }],

    // BigFlo-to-BigFlo operations (uses PARSED symbol fast path)
    ['BigFlo(a).plus(BigFlo(b)) uses fast path', () => {
        const a = BigFlo('123.456');
        const b = BigFlo('789.012');
        const actual = BigFlo(a).plus(b).toString();
        const expect = '912.468';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(a).times(BigFlo(b)) uses fast path', () => {
        const a = BigFlo('12.5');
        const b = BigFlo('8');
        const actual = BigFlo(a).times(b).toString();
        const expect = '100';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(a).isGreaterThan(BigFlo(b)) uses fast path', () => {
        const a = BigFlo('100.5');
        const b = BigFlo('100.4');
        const actual = a.isGreaterThan(b);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // Associativity
    ['Associativity: (a+b)+c === a+(b+c)', () => {
        const a = "111.111", b = "222.222", c = "333.333";
        const left = BigFlo(a).plus(b).plus(c).toString();
        const right = BigFlo(a).plus(BigFlo(b).plus(c)).toString();
        const result = left === right;
        return { result, expect: true, actual: `${left} vs ${right}` };
    }],

    // isInteger after operations that produce whole numbers
    ['BigFlo("1.5").plus("0.5").isInteger()', () => {
        const actual = BigFlo("1.5").plus("0.5").isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.5").times("2").isInteger()', () => {
        const actual = BigFlo("0.5").times("2").isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("3").div("1.5").isInteger()', () => {
        const actual = BigFlo("3").div("1.5").isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1.001").times("1000").isInteger()', () => {
        const actual = BigFlo("1.001").times("1000").isInteger();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // Extreme scale operations
    ['1e-100 + 1e-100 = 2e-100', () => {
        const actual = BigFlo('1e-100').plus('1e-100').toString();
        const result = actual === '0.' + '0'.repeat(99) + '2';
        return { result, expect: '2e-100', actual: actual.length + ' chars' };
    }],

    ['1e50 + 1e-50 preserves both ends', () => {
        const actual = BigFlo('1e50').plus('1e-50').toString();
        const result = actual.startsWith('1' + '0'.repeat(49)) && actual.endsWith('1');
        return { result, expect: true, actual: actual.length + ' chars' };
    }],

    ['0^0 = 1', () => {
        const actual = BigFlo(0).pow(0).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['2^200 has 61 digits', () => {
        const actual = BigFlo(2).pow(200).toString();
        const expect = 61;
        const result = actual.length === expect;
        return { result, expect, actual: actual.length };
    }],

    // BigFlo as operand in all operations
    ['BigFlo - BigFlo: 5 - 2.5 = 2.5', () => {
        const actual = BigFlo('5').minus(BigFlo('2.5')).toString();
        const expect = '2.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo ** BigFlo: 2^10 = 1024', () => {
        const actual = BigFlo('2').pow(BigFlo('10')).toString();
        const expect = '1024';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — neg()
    // ========================================

    ['BigFlo(5).neg()', () => {
        const actual = BigFlo(5).neg().toString();
        const expect = '-5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-5).neg()', () => {
        const actual = BigFlo(-5).neg().toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).neg()', () => {
        const actual = BigFlo(0).neg().toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("3.14").neg()', () => {
        const actual = BigFlo("3.14").neg().toString();
        const expect = '-3.14';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — mod()
    // ========================================

    ['10 % 3 = 1', () => {
        const actual = BigFlo(10).mod(3).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['7 % 2 = 1', () => {
        const actual = BigFlo(7).mod(2).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-10 % 3 = -1', () => {
        const actual = BigFlo(-10).mod(3).toString();
        const expect = '-1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['10.5 % 3 = 1.5', () => {
        const actual = BigFlo("10.5").mod(3).toString();
        const expect = '1.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['100 % 7 = 2', () => {
        const actual = BigFlo(100).mod(7).toString();
        const expect = '2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ["10 % 3 via ['%']", () => {
        const actual = BigFlo(10)['%'](3).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — divToInt()
    // ========================================

    ['10 divToInt 3 = 3', () => {
        const actual = BigFlo(10).divToInt(3).toString();
        const expect = '3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['7 divToInt 2 = 3', () => {
        const actual = BigFlo(7).divToInt(2).toString();
        const expect = '3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['-7 divToInt 2 = -3', () => {
        const actual = BigFlo(-7).divToInt(2).toString();
        const expect = '-3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['10.5 divToInt 3 = 3', () => {
        const actual = BigFlo("10.5").divToInt(3).toString();
        const expect = '3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — isZero()
    // ========================================

    ['BigFlo(0).isZero()', () => {
        const actual = BigFlo(0).isZero();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(1).isZero()', () => {
        const actual = BigFlo(1).isZero();
        const expect = false;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-0).isZero()', () => {
        const actual = BigFlo(-0).isZero();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.0").isZero()', () => {
        const actual = BigFlo("0.0").isZero();
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — cmp()
    // ========================================

    ['BigFlo(5).cmp(3) = 1', () => {
        const actual = BigFlo(5).cmp(3);
        const expect = 1;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(3).cmp(5) = -1', () => {
        const actual = BigFlo(3).cmp(5);
        const expect = -1;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).cmp(5) = 0', () => {
        const actual = BigFlo(5).cmp(5);
        const expect = 0;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — shiftedBy()
    // ========================================

    ['BigFlo(1).shiftedBy(3) = 1000', () => {
        const actual = BigFlo(1).shiftedBy(3).toString();
        const expect = '1000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(1234).shiftedBy(-2) = 12.34', () => {
        const actual = BigFlo(1234).shiftedBy(-2).toString();
        const expect = '12.34';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("5.5").shiftedBy(1) = 55', () => {
        const actual = BigFlo("5.5").shiftedBy(1).toString();
        const expect = '55';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — clamp()
    // ========================================

    ['BigFlo(5).clamp(1, 10) = 5', () => {
        const actual = BigFlo(5).clamp(1, 10).toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-5).clamp(0, 10) = 0', () => {
        const actual = BigFlo(-5).clamp(0, 10).toString();
        const expect = '0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(15).clamp(0, 10) = 10', () => {
        const actual = BigFlo(15).clamp(0, 10).toString();
        const expect = '10';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — toExponential()
    // ========================================

    ['BigFlo(123.456).toExponential()', () => {
        const actual = BigFlo(123.456).toExponential();
        const expect = '1.23456e+2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123.456).toExponential(2)', () => {
        const actual = BigFlo(123.456).toExponential(2);
        const expect = '1.23e+2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.001).toExponential()', () => {
        const actual = BigFlo(0.001).toExponential();
        const expect = '1e-3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0).toExponential()', () => {
        const actual = BigFlo(0).toExponential();
        const expect = '0e+0';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(-456.789).toExponential(1)', () => {
        const actual = BigFlo(-456.789).toExponential(1);
        const expect = '-4.5e+2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — toPrecision()
    // ========================================

    ['BigFlo(123.456).toPrecision(5)', () => {
        const actual = BigFlo(123.456).toPrecision(5);
        const expect = '123.45';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(123.456).toPrecision(2)', () => {
        const actual = BigFlo(123.456).toPrecision(2);
        const expect = '1.2e+2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(0.001234).toPrecision(3)', () => {
        const actual = BigFlo(0.001234).toPrecision(3);
        const expect = '0.00123';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(5).toPrecision()', () => {
        const actual = BigFlo(5).toPrecision();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Static methods
    // ========================================

    ['BigFlo.abs(-5)', () => {
        const actual = BigFlo.abs(-5).toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.ceil(4.1)', () => {
        const actual = BigFlo.ceil(4.1).toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.floor(4.9)', () => {
        const actual = BigFlo.floor(4.9).toString();
        const expect = '4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.round(4.5)', () => {
        const actual = BigFlo.round(4.5).toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.trunc(4.9)', () => {
        const actual = BigFlo.trunc(4.9).toString();
        const expect = '4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.sign(-42)', () => {
        const actual = BigFlo.sign(-42).toString();
        const expect = '-1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.pow(2, 10)', () => {
        const actual = BigFlo.pow(2, 10).toString();
        const expect = '1024';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.max(1, 5, 3, 2, 4)', () => {
        const actual = BigFlo.max(1, 5, 3, 2, 4).toString();
        const expect = '5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.min(5, 1, 3, 2, 4)', () => {
        const actual = BigFlo.min(5, 1, 3, 2, 4).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.sum(1, 2, 3, 4, 5)', () => {
        const actual = BigFlo.sum(1, 2, 3, 4, 5).toString();
        const expect = '15';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.add("0.1", "0.2")', () => {
        const actual = BigFlo.add("0.1", "0.2").toString();
        const expect = '0.3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.sub("0.3", "0.2")', () => {
        const actual = BigFlo.sub("0.3", "0.2").toString();
        const expect = '0.1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.mul("0.6", "3")', () => {
        const actual = BigFlo.mul("0.6", "3").toString();
        const expect = '1.8';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.div("0.3", "0.1")', () => {
        const actual = BigFlo.div("0.3", "0.1").toString();
        const expect = '3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.mod(10, 3)', () => {
        const actual = BigFlo.mod(10, 3).toString();
        const expect = '1';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.max("0.1", "0.2", "0.15")', () => {
        const actual = BigFlo.max("0.1", "0.2", "0.15").toString();
        const expect = '0.2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.min("-5", "0", "5")', () => {
        const actual = BigFlo.min("-5", "0", "5").toString();
        const expect = '-5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.sum("0.1", "0.2", "0.3")', () => {
        const actual = BigFlo.sum("0.1", "0.2", "0.3").toString();
        const expect = '0.6';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — sqrt / cbrt
    // ========================================

    ['BigFlo(4).sqrt() = 2', () => {
        const actual = BigFlo(4).sqrt().toString();
        const result = actual === '2';
        return { result, expect: '2', actual };
    }],

    ['BigFlo(9).sqrt() = 3', () => {
        const actual = BigFlo(9).sqrt().toString();
        const result = actual === '3';
        return { result, expect: '3', actual };
    }],

    ['BigFlo(2).sqrt() starts with 1.41421356', () => {
        const actual = BigFlo(2).sqrt().toString();
        const result = actual.startsWith('1.41421356');
        return { result, expect: '1.41421356...', actual: actual.slice(0, 15) };
    }],

    ['BigFlo(0).sqrt() = 0', () => {
        const actual = BigFlo(0).sqrt().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(-1).sqrt() = NaN', () => {
        const actual = BigFlo(-1).sqrt().toString();
        const result = actual === 'NaN';
        return { result, expect: 'NaN', actual };
    }],

    ['BigFlo(27).cbrt() = 3', () => {
        const actual = BigFlo(27).cbrt().toString();
        const result = actual === '3';
        return { result, expect: '3', actual };
    }],

    ['BigFlo(8).cbrt() = 2', () => {
        const actual = BigFlo(8).cbrt().toString();
        const result = actual === '2';
        return { result, expect: '2', actual };
    }],

    ['BigFlo(-8).cbrt() starts with -2', () => {
        const actual = BigFlo(-8).cbrt().toString();
        const result = actual.startsWith('-2');
        return { result, expect: '-2...', actual: actual.slice(0, 10) };
    }],

    // ========================================
    // NEW TESTS — exp / log
    // ========================================

    ['BigFlo(0).exp() = 1', () => {
        const actual = BigFlo(0).exp().toString();
        const result = actual === '1';
        return { result, expect: '1', actual };
    }],

    ['BigFlo(1).exp() starts with 2.71828', () => {
        const actual = BigFlo(1).exp().toString();
        const result = actual.startsWith('2.71828');
        return { result, expect: '2.71828...', actual: actual.slice(0, 10) };
    }],

    ['BigFlo(1).log() = 0', () => {
        const actual = BigFlo(1).log().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(2).log() starts with 0.69314', () => {
        const actual = BigFlo(2).log().toString();
        const result = actual.startsWith('0.69314');
        return { result, expect: '0.69314...', actual: actual.slice(0, 10) };
    }],

    ['BigFlo(100).log10() = 2', () => {
        const actual = BigFlo(100).log10().toString();
        const result = actual.startsWith('2');
        return { result, expect: '2', actual: actual.slice(0, 5) };
    }],

    ['BigFlo(8).log2() = 3', () => {
        const actual = BigFlo(8).log2().toString();
        const result = actual === '3';
        return { result, expect: '3', actual };
    }],

    ['BigFlo(0).log() = -Infinity', () => {
        const actual = BigFlo(0).log().toString();
        const result = actual === '-Infinity';
        return { result, expect: '-Infinity', actual };
    }],

    ['BigFlo(-1).log() = NaN', () => {
        const actual = BigFlo(-1).log().toString();
        const result = actual === 'NaN';
        return { result, expect: 'NaN', actual };
    }],

    // ========================================
    // NEW TESTS — Trig
    // ========================================

    ['BigFlo(0).sin() = 0', () => {
        const actual = BigFlo(0).sin().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(0).cos() starts with 1', () => {
        const actual = BigFlo(0).cos().toString();
        const result = actual.startsWith('1');
        return { result, expect: '1', actual: actual.slice(0, 5) };
    }],

    ['BigFlo(0).tan() = 0', () => {
        const actual = BigFlo(0).tan().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(0).asin() = 0', () => {
        const actual = BigFlo(0).asin().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(0).atan() = 0', () => {
        const actual = BigFlo(0).atan().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(1).asin() ≈ PI/2', () => {
        const actual = BigFlo(1).asin().toString();
        const result = actual.startsWith('1.5707963');
        return { result, expect: '1.5707963...', actual: actual.slice(0, 12) };
    }],

    ['BigFlo.PI starts with 3.14159265', () => {
        const actual = BigFlo.PI.toString();
        const result = actual.startsWith('3.14159265');
        return { result, expect: '3.14159265...', actual: actual.slice(0, 15) };
    }],

    ['BigFlo.E starts with 2.71828182', () => {
        const actual = BigFlo.E.toString();
        const result = actual.startsWith('2.71828182');
        return { result, expect: '2.71828182...', actual: actual.slice(0, 15) };
    }],

    // ========================================
    // NEW TESTS — Hyperbolic
    // ========================================

    ['BigFlo(0).sinh() = 0', () => {
        const actual = BigFlo(0).sinh().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(1).sinh() starts with 1.17520', () => {
        const actual = BigFlo(1).sinh().toString();
        const result = actual.startsWith('1.17520');
        return { result, expect: '1.17520...', actual: actual.slice(0, 10) };
    }],

    ['BigFlo(0).cosh() = 1', () => {
        const actual = BigFlo(0).cosh().toString();
        const result = actual === '1';
        return { result, expect: '1', actual };
    }],

    ['BigFlo(0).tanh() = 0', () => {
        const actual = BigFlo(0).tanh().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    // ========================================
    // NEW TESTS — Inverse hyperbolic
    // ========================================

    ['BigFlo(0).asinh() = 0', () => {
        const actual = BigFlo(0).asinh().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(1).acosh() = 0', () => {
        const actual = BigFlo(1).acosh().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo(0).atanh() = 0', () => {
        const actual = BigFlo(0).atanh().toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    // ========================================
    // NEW TESTS — Static advanced math
    // ========================================

    ['BigFlo.sqrt(16) = 4', () => {
        const actual = BigFlo.sqrt(16).toString();
        const result = actual === '4';
        return { result, expect: '4', actual };
    }],

    ['BigFlo.hypot(3, 4) ≈ 5', () => {
        const actual = BigFlo.hypot(3, 4).toString();
        const result = actual.startsWith('5');
        return { result, expect: '5', actual: actual.slice(0, 5) };
    }],

    ['BigFlo.SQRT2 starts with 1.41421', () => {
        const actual = BigFlo.SQRT2.toString();
        const result = actual.startsWith('1.41421');
        return { result, expect: '1.41421...', actual: actual.slice(0, 10) };
    }],

    ['BigFlo.LN2 starts with 0.69314', () => {
        const actual = BigFlo.LN2.toString();
        const result = actual.startsWith('0.69314');
        return { result, expect: '0.69314...', actual: actual.slice(0, 10) };
    }],

    ['BigFlo.random() is between 0 and 1', () => {
        const r = BigFlo.random();
        const actual = r.gte(0) && r.lt(1);
        const result = actual === true;
        return { result, expect: true, actual };
    }],

    // ========================================
    // NEW TESTS — Rounding modes
    // ========================================

    ['toDP(2, ROUND_UP) 1.234 = 1.24', () => {
        const actual = BigFlo('1.234').toDP(2, BigFlo.ROUND_UP).toString();
        const expect = '1.24';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['toDP(2, ROUND_DOWN) 1.236 = 1.23', () => {
        const actual = BigFlo('1.236').toDP(2, BigFlo.ROUND_DOWN).toString();
        const expect = '1.23';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['toDP(2, ROUND_CEIL) -1.234 = -1.23', () => {
        const actual = BigFlo('-1.234').toDP(2, BigFlo.ROUND_CEIL).toString();
        const expect = '-1.23';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['toDP(2, ROUND_FLOOR) -1.234 = -1.24', () => {
        const actual = BigFlo('-1.234').toDP(2, BigFlo.ROUND_FLOOR).toString();
        const expect = '-1.24';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['toDP(0, ROUND_HALF_EVEN) 2.5 = 2', () => {
        const actual = BigFlo('2.5').toDP(0, BigFlo.ROUND_HALF_EVEN).toString();
        const expect = '2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['toDP(0, ROUND_HALF_EVEN) 3.5 = 4', () => {
        const actual = BigFlo('3.5').toDP(0, BigFlo.ROUND_HALF_EVEN).toString();
        const expect = '4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['toDP(0, ROUND_HALF_UP) 2.5 = 3', () => {
        const actual = BigFlo('2.5').toDP(0, BigFlo.ROUND_HALF_UP).toString();
        const expect = '3';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['toDP(0, ROUND_HALF_DOWN) 2.5 = 2', () => {
        const actual = BigFlo('2.5').toDP(0, BigFlo.ROUND_HALF_DOWN).toString();
        const expect = '2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Non-integer exponents
    // ========================================

    ['4^0.5 ≈ 2', () => {
        const actual = BigFlo(4).pow('0.5').toString();
        const result = actual.startsWith('1.999') || actual.startsWith('2');
        return { result, expect: '~2', actual: actual.slice(0, 20) };
    }],

    ['2^1.5 ≈ 2.828', () => {
        const actual = BigFlo(2).pow('1.5').toString();
        const result = actual.startsWith('2.828');
        return { result, expect: '~2.828', actual: actual.slice(0, 10) };
    }],

    // ========================================
    // NEW TESTS — toFraction
    // ========================================

    ['BigFlo("0.5").toFraction() = 1/2', () => {
        const [num, den] = BigFlo('0.5').toFraction();
        const actual = num.toString() + '/' + den.toString();
        const expect = '1/2';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.25").toFraction() = 1/4', () => {
        const [num, den] = BigFlo('0.25').toFraction();
        const actual = num.toString() + '/' + den.toString();
        const expect = '1/4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.75").toFraction() = 3/4', () => {
        const [num, den] = BigFlo('0.75').toFraction();
        const actual = num.toString() + '/' + den.toString();
        const expect = '3/4';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Base conversion
    // ========================================

    ['BigFlo(255).toBinary()', () => {
        const actual = BigFlo(255).toBinary();
        const expect = '11111111';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(255).toHex()', () => {
        const actual = BigFlo(255).toHex();
        const expect = 'ff';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(255).toOctal()', () => {
        const actual = BigFlo(255).toOctal();
        const expect = '377';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.fromHex("ff") = 255', () => {
        const actual = BigFlo.fromHex('ff').toString();
        const expect = '255';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.fromBinary("1010") = 10', () => {
        const actual = BigFlo.fromBinary('1010').toString();
        const expect = '10';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.fromOctal("77") = 63', () => {
        const actual = BigFlo.fromOctal('77').toString();
        const expect = '63';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(10).toBase(2)', () => {
        const actual = BigFlo(10).toBase(2);
        const expect = '1010';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.fromBase("ff", 16) = 255', () => {
        const actual = BigFlo.fromBase('ff', 16).toString();
        const expect = '255';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — toFormat
    // ========================================

    ['BigFlo(1000000).toFormat()', () => {
        const actual = BigFlo(1000000).toFormat();
        const expect = '1,000,000';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("1234567.89").toFormat(2)', () => {
        const actual = BigFlo('1234567.89').toFormat(2);
        const expect = '1,234,567.89';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(1234567).toFormat with custom separators', () => {
        const actual = BigFlo(1234567).toFormat({ groupSeparator: '.', decimalSeparator: ',' });
        const expect = '1.234.567';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo(1000).toFormat with prefix/suffix', () => {
        const actual = BigFlo(1000).toFormat({ prefix: '$', suffix: ' USD' });
        const expect = '$1,000 USD';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Rounding mode constants
    // ========================================

    ['BigFlo.ROUND_UP = 0', () => {
        const actual = BigFlo.ROUND_UP;
        const expect = 0;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.ROUND_HALF_EVEN = 6', () => {
        const actual = BigFlo.ROUND_HALF_EVEN;
        const expect = 6;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    // ========================================
    // NEW TESTS — Missing coverage: ln, toSD, static math
    // ========================================

    ['BigFlo(2).ln() starts with 0.69314', () => {
        const actual = BigFlo(2).ln().toString();
        const result = actual.startsWith('0.69314');
        return { result, expect: '0.69314...', actual: actual.slice(0, 10) };
    }],

    ['BigFlo("123.456").toSD(4)', () => {
        const actual = BigFlo("123.456").toSD(4).toString();
        const expect = '123.5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo("0.001234").toSD(2)', () => {
        const actual = BigFlo("0.001234").toSD(2).toString();
        const expect = '0.0012';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.neg(5)', () => {
        const actual = BigFlo.neg(5).toString();
        const expect = '-5';
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['BigFlo.cbrt(27)', () => {
        const actual = BigFlo.cbrt(27).toString();
        const result = actual === '3';
        return { result, expect: '3', actual };
    }],

    ['BigFlo.exp(0)', () => {
        const actual = BigFlo.exp(0).toString();
        const result = actual === '1';
        return { result, expect: '1', actual };
    }],

    ['BigFlo.log(1)', () => {
        const actual = BigFlo.log(1).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.log2(8)', () => {
        const actual = BigFlo.log2(8).toString();
        const result = actual === '3';
        return { result, expect: '3', actual };
    }],

    ['BigFlo.log10(1000)', () => {
        const actual = BigFlo.log10(1000).toString();
        const result = actual.startsWith('3');
        return { result, expect: '3', actual: actual.slice(0, 5) };
    }],

    ['BigFlo.sin(0)', () => {
        const actual = BigFlo.sin(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.cos(0)', () => {
        const actual = BigFlo.cos(0).toString();
        const result = actual.startsWith('1');
        return { result, expect: '1', actual: actual.slice(0, 5) };
    }],

    ['BigFlo.tan(0)', () => {
        const actual = BigFlo.tan(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.asin(0)', () => {
        const actual = BigFlo.asin(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.acos(0) ≈ PI/2', () => {
        const actual = BigFlo.acos(0).toString();
        const result = actual.startsWith('1.5707963');
        return { result, expect: '1.5707963...', actual: actual.slice(0, 12) };
    }],

    ['BigFlo.atan(0)', () => {
        const actual = BigFlo.atan(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.atan2(1, 1) ≈ PI/4', () => {
        const actual = BigFlo.atan2(1, 1).toString();
        const result = actual.startsWith('0.78');
        return { result, expect: '~0.785 (PI/4)', actual: actual.slice(0, 12) };
    }],

    ['BigFlo.sinh(0)', () => {
        const actual = BigFlo.sinh(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.cosh(0)', () => {
        const actual = BigFlo.cosh(0).toString();
        const result = actual === '1';
        return { result, expect: '1', actual };
    }],

    ['BigFlo.tanh(0)', () => {
        const actual = BigFlo.tanh(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.asinh(0)', () => {
        const actual = BigFlo.asinh(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.acosh(1)', () => {
        const actual = BigFlo.acosh(1).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    ['BigFlo.atanh(0)', () => {
        const actual = BigFlo.atanh(0).toString();
        const result = actual === '0';
        return { result, expect: '0', actual };
    }],

    // ========================================
    // NEW TESTS — compress / decompress
    // ========================================

    ['BigFlo.compress/decompress string roundtrip', () => {
        const input = 'Hello, World!';
        const compressed = BigFlo.compress(input);
        const output = BigFlo.decompress(compressed);
        const result = output === input;
        return { result, expect: input, actual: output };
    }],

    ['compress protocol format: starts with base number and dot', () => {
        const compressed = BigFlo.compress('test');
        const actual = /^\d+\./.test(compressed);
        const expect = true;
        const result = actual === expect;
        return { result, expect, actual };
    }],

    ['compress/decompress array with leading zeros', () => {
        const input = [0, 0, 0, 1, 2, 3];
        const compressed = BigFlo.compress(input);
        const output = BigFlo.decompress(compressed, 'array');
        const result = JSON.stringify(output) === JSON.stringify(input);
        return { result, expect: JSON.stringify(input), actual: JSON.stringify(output) };
    }],

    ['compress/decompress all zeros', () => {
        const input = [0, 0, 0, 0, 0];
        const compressed = BigFlo.compress(input);
        const output = BigFlo.decompress(compressed, 'array');
        const result = JSON.stringify(output) === JSON.stringify(input);
        return { result, expect: JSON.stringify(input), actual: JSON.stringify(output) };
    }],

    ['compress/decompress single value [0]', () => {
        const input = [0];
        const compressed = BigFlo.compress(input);
        const output = BigFlo.decompress(compressed, 'array');
        const result = JSON.stringify(output) === JSON.stringify(input);
        return { result, expect: JSON.stringify(input), actual: JSON.stringify(output) };
    }],

    ['compress/decompress Uint8Array', () => {
        const input = new Uint8Array([255, 0, 128, 64, 1]);
        const compressed = BigFlo.compress(input);
        const output = BigFlo.decompress(compressed, 'uint8array');
        const result = input.length === output.length && input.every((v, i) => v === output[i]);
        return { result, expect: [...input].join(','), actual: [...output].join(',') };
    }],

    ['compress detects minimum base from data', () => {
        const compressed = BigFlo.compress([0, 1, 2, 3]);
        const base = parseInt(compressed.split('.')[0], 10);
        const result = base === 4;
        return { result, expect: 4, actual: base };
    }],

    ['compress reduces size', () => {
        const input = 'The quick brown fox jumps over the lazy dog';
        const compressed = BigFlo.compress(input);
        const payloadLen = [...compressed.slice(compressed.indexOf('.') + 1)].length;
        const result = payloadLen < input.length;
        return { result, expect: true, actual: payloadLen + ' < ' + input.length };
    }],

    // Distributivity
    ['Distributivity: a*(b+c) === a*b + a*c', () => {
        const a = "5", b = "3", c = "7";
        const left = BigFlo(a).times(BigFlo(b).plus(c)).toString();
        const right = BigFlo(a).times(b).plus(BigFlo(a).times(c)).toString();
        const result = left === right;
        return { result, expect: true, actual: `${left} vs ${right}` };
    }],

];

function runTests(tests) {
    let passed = 0;
    let failed = [];
    let totalTime = 0;

    console.log(`---`);

    for (const [description, testFn] of tests) {

        console.log(`test: ${description}`);
        const startTime = performance.now();

        let testData;
        try {
            testData = testFn();

        } catch (err) {
            console.log(`ERROR: `, err.message, err.stack);
            testData = null;
        }
        const endTime = performance.now();
        const testDuration = endTime - startTime;

        totalTime += testDuration;

        const expected = `expect: ${testData?.expect}`;
        const actual = `actual: ${testData?.actual}`;
        const testResultDisplay = `\n${expected}\n${actual}`;
        console.log(testResultDisplay);

        if (testData?.result) {
            console.log(`\nOK`);
            passed++;
        } else {
            console.log(`\n !!! FAILED !!!`);
            failed.push([ description, expected, actual ]);
        }
        console.log(`---`);
    }

    console.log(`\nTest Results: ${passed} Passed, ${failed.length} Failed, ${tests.length} Total`);
    console.log(`Total Time: ${totalTime.toFixed(2)}ms`);

    if (failed.length) {
        console.log(`FAILED TESTS: ${JSON.stringify(failed, null, 1)}`);
    } else {
        console.log(`\nSUCCESS!!! No failed tests ;D`);
    }
}

runTests(tests);