/**********************************************************************
*
* Float to string Test
*
**********************************************************************/
import strconv
import math

union Ufloat32 {
mut:
    f f32 = f32(0)
    b u32
}

union Ufloat64 {
mut:
    f f64 = f64(0)
    b u64
}

fn f64_from_bits1(b u64) f64 {
    mut x := Ufloat64{}
    x.b = b
    // C.printf("bin: %016llx\n",x.f)
    return unsafe { x.f }
}

fn f32_from_bits1(b u32) f32 {
    mut x := Ufloat32{}
    x.b = b
    // C.printf("bin: %08x\n",x.f)
    return unsafe { x.f }
}

fn test_float_to_str() {
    test_cases_f32 := [
        f32_from_bits1(0x0000_0000), // +0
        f32_from_bits1(0x8000_0000), // -0
        f32_from_bits1(0xFFC0_0001), // sNan
        f32_from_bits1(0xFF80_0001), // qNan
        f32_from_bits1(0x7F80_0000), // +inf
        f32_from_bits1(0xFF80_0000), // -inf
        1,
        -1,
        10,
        -10,
        0.3,
        -0.3,
        1000000,
        123456.7,
        123e35,
        -123.45,
        1e23,
        f32_from_bits1(0x0080_0000), // smallest float32
        math.max_f32,
        383260575764816448.0,
    ]

    exp_result_f32 := [
        '0e+00',
        '-0e+00',
        'nan',
        'nan',
        '+inf',
        '-inf',
        '1.e+00',
        '-1.e+00',
        '1.e+01',
        '-1.e+01',
        '3.e-01',
        '-3.e-01',
        '1.e+06',
        '1.234567e+05',
        '1.23e+37',
        '-1.2345e+02',
        '1.e+23',
        '1.1754944e-38', // aprox from 1.1754943508 × 10−38,
        '3.4028235e+38',
        '3.8326058e+17',
    ]

    test_cases_f64 := [
        f64_from_bits1(0x0000_0000_0000_0000), // +0
        f64_from_bits1(0x8000_0000_0000_0000), // -0
        f64_from_bits1(0x7FF0_0000_0000_0001), // sNan
        f64_from_bits1(0x7FF8_0000_0000_0001), // qNan
        f64_from_bits1(0x7FF0_0000_0000_0000), // +inf
        f64_from_bits1(0xFFF0_0000_0000_0000), // -inf
        1,
        -1,
        10,
        -10,
        0.3,
        -0.3,
        1000000,
        123456.7,
        123e45,
        -123.45,
        1e23,
        f64_from_bits1(0x0010_0000_0000_0000), // smallest float64
        math.max_f32,
        383260575764816448,
        383260575764816448,
        // C failing cases
        123e300,
        123e-300,
        5.e-324,
        -5.e-324,
    ]

    exp_result_f64 := [
        '0e+00',
        '-0e+00',
        'nan',
        'nan',
        '+inf',
        '-inf',
        '1.e+00',
        '-1.e+00',
        '1.e+01',
        '-1.e+01',
        '3.e-01',
        '-3.e-01',
        '1.e+06',
        '1.234567e+05',
        '1.23e+47',
        '-1.2345e+02',
        '1.e+23',
        '2.2250738585072014e-308',
        '3.4028234663852886e+38',
        '3.8326057576481645e+17',
        '3.8326057576481645e+17',
        '1.23e+302', // this test is failed from C sprintf!!
        '1.23e-298',
        '5.e-324',
        '-5.e-324',
    ]

    // test f32
    for c, x in test_cases_f32 {
        // println(x)
        s := strconv.f32_to_str(x, 8)
        s1 := exp_result_f32[c]
        // println("$s1 $s")
        assert s == s1
    }

    // test f64
    for c, x in test_cases_f64 {
        s := strconv.f64_to_str(x, 17)
        s1 := exp_result_f64[c]
        // println("$s1 $s")
        assert s == s1
    }

    // test long format
    assert strconv.f64_to_str_l('1e1'.f64()).len == 4 // '10.0'
    assert strconv.f64_to_str_l('1e-1'.f64()).len == 3 // '0.1'

    for exp := 2; exp < 120; exp++ {
        a := strconv.f64_to_str_l(('1e' + exp.str()).f64())
        // println(a)
        assert a.len == exp + 3

        b := strconv.f64_to_str_l(('1e-' + exp.str()).f64())
        // println(b)
        assert b.len == exp + 2
    }

    // test rounding str conversion
    // println( ftoa.f64_to_str(0.3456789123456, 4) )
    // assert ftoa.f64_to_str(0.3456789123456, 4)=="3.4568e-01"
    // assert ftoa.f32_to_str(0.345678, 3)=="3.457e-01"
}