Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.1

0.6.1 / src / ak / tests_format_2.lucb

#==============================================================================================
#
#   tests_format_2 - tests of the format fragments: floats, spans, Checked, Duration
#
#   DESCRIPTION:
#       The second half of the port of Tests/AK/TestFormat.cpp (Ladybird 47c82b38d0), from
#       floating_point_numbers on, and its format_duration case (Formatter<Duration> is
#       time_format's). The helpers are tests_format's.
#
#==============================================================================================

# mark: TestFormat.cpp, continued ===============================================================

test "floating_point_numbers":
    assert(formatted("{}", [arg_f64(1.12)]) == "1.12")
    assert(formatted("{}", [arg_f64(1.0)]) == "1")
    assert(formatted("{:.3}", [arg_f64(1.12)]) == "1.12")
    assert(formatted("{:.1}", [arg_f64(1.12)]) == "1.1")
    assert(formatted("{}", [arg_f64(-1.12)]) == "-1.12")
    assert(formatted("{:'.4}", [arg_f64(1234.5678)]) == "1,234.5678")
    assert(formatted("{:'.4}", [arg_f64(-1234.5678)]) == "-1,234.5678")

    let float_max = f32.bits(0x7f7fffff)
    assert(formatted("{:.5}", [arg_f64(1.2345678e-15)]) == "1.23456e-15")
    assert(formatted("{:.5}", [arg_f32(float_max)]) == "3.40282e+38")
    assert(formatted("{:.5}", [arg_f32(-float_max)]) == "-3.40282e+38")
    assert(formatted("{:.5}", [arg_f64(3.000001e30)]) == "3e+30")
    assert(formatted("{:.5}", [arg_f64(3.1e30)]) == "3.1e+30")

    assert(formatted("{:.30f}", [arg_f64(1.0)]) == "1.000000000000000000000000000000")
    assert(formatted("{:.30f}", [arg_f64(1.5)]) == "1.500000000000000000000000000000")
    assert(formatted("{:.30f}", [arg_f64(-2.0)]) == "-2.000000000000000000000000000000")

    assert(formatted("{:.0f}", [arg_f64(1.4)]) == "1")
    assert(formatted("{:.0f}", [arg_f64(1.5)]) == "2")
    assert(formatted("{:.0f}", [arg_f64(-1.9)]) == "-2")

    assert(formatted("{:.1f}", [arg_f64(1.4)]) == "1.4")
    assert(formatted("{:.1f}", [arg_f64(1.99)]) == "2.0")
    assert(formatted("{:.1f}", [arg_f64(9.999)]) == "10.0")

    # NAN and INFINITY are floats in C.
    assert(formatted("{}", [arg_f32((f32)math.nan)]) == "nan")
    assert(formatted("{}", [arg_f32((f32)math.infinity)]) == "inf")
    assert(formatted("{}", [arg_f32((f32)-math.infinity)]) == "-inf")

    # FIXME: There is always the question what we mean with the width field. Do we mean significant digits?
    #        Do we mean the whole width? This is what was the simplest to implement:
    assert(formatted("{:x>5.1}", [arg_f64(1.12)]) == "xx1.1")

test "floating_point_default_precision":
    assert(formatted("{}", [arg_f32(10.3)]) == "10.3")
    assert(formatted("{}", [arg_f32(123e4)]) == "1230000")
    assert(formatted("{}", [arg_f32(1.23e4)]) == "12300")
    assert(formatted("{}", [arg_f32(134232544.4365)]) == "134232540")
    assert(formatted("{}", [arg_f64(1.43e24)]) == "1.43e+24")
    assert(formatted("{}", [arg_f64(1.43e-24)]) == "1.43e-24")
    assert(formatted("{}", [arg_f32(0.0)]) == "0")
    assert(formatted("{}", [arg_f64(3.14159265358979)]) == "3.14159265358979")
    assert(formatted("{}", [arg_f64(1.61803399)]) == "1.61803399")
    assert(formatted("{}", [arg_f64(2.71827)]) == "2.71827")
    assert(formatted("{}", [arg_f32(42.0)]) == "42")
    assert(formatted("{}", [arg_f64(123456.78)]) == "123456.78")
    assert(formatted("{}", [arg_f64(23456.78910)]) == "23456.7891")

## Not in TestFormat.cpp: values whose two shortest round-trip candidates are equally close.
## Dragonbox takes the even one; the texts are AK's own, printed by the local oracle
## (luce-browser-tools oracles/luce-browser-foundation/float_format_oracle.cpp, linked against
## the reference build's AK), which agrees with this port on 80,013 values.
test "floating_point_default_precision: ties round to even":
    assert(formatted("{}", [arg_f32(128.328125)]) == "128.32812")
    assert(formatted("{}", [arg_f32(144.203125)]) == "144.20312")
    assert(formatted("{}", [arg_f32(264.640625)]) == "264.64062")
    assert(formatted("{}", [arg_f32(53.7265625)]) == "53.726562")
    assert(formatted("{}", [arg_f32(f32.bits(0x455d1880))]) == "3537.5312")
    assert(formatted("{}", [arg_f32(f32.bits(0x404c4000))]) == "3.1914062")
    assert(formatted("{}", [arg_f32(f32.bits(0x3d540000))]) == "0.051757812")
    assert(formatted("{}", [arg_f32(f32.bits(0xbb900000))]) == "-0.0043945312")
    assert(formatted("{}", [arg_f32(f32.bits(0x489607d4))]) == "307262.62")
    assert(formatted("{}", [arg_f32(f32.bits(0xca27106d))]) == "-2737179.2")
    # A power of two (Dragonbox's shorter_interval_case).
    assert(formatted("{}", [arg_f32(f32.bits(0x39800000))]) == "0.00024414062")
    assert(formatted("{}", [arg_f64(-10.2350006103515625)]) == "-10.235000610351562")
    assert(formatted("{}", [arg_f64(f64.bits(0x4065d34b40000000))]) == "174.60293579101562")
    assert(formatted("{}", [arg_f64(f64.bits(0x408afa61a0000000))]) == "863.2976684570312")
    assert(formatted("{}", [arg_f64(f64.bits(0x4001c9d400000000))]) == "2.2235488891601562")
    assert(formatted("{}", [arg_f64(f64.bits(0x431dc7f5737a7d35))]) == "2095657835732813.2")
    assert(formatted("{}", [arg_f64(f64.bits(0xc3132ee1fbfa34bd))]) == "-1349893171875119.2")
    # Not ties: the closer candidate wins whatever its parity.
    assert(formatted("{}", [arg_f32(f32.bits(0x430053ff))]) == "128.32811")

test "no_precision_no_trailing_number":
    assert(formatted("{:.0}", [arg_f64(0.1)]) == "0")

test "precision_with_trailing_zeros":
    assert(formatted("{:0.3f}", [arg_f64(1.12)]) == "1.120")
    assert(formatted("{:0.3}", [arg_f64(1.12)]) == "1.12")
    assert(formatted("{:0.1}", [arg_f64(1.12)]) == "1.1")

test "magnitude_less_than_zero":
    assert(formatted("{}", [arg_f64(-0.654)]) == "-0.654")
    assert(formatted("{}", [arg_f64(0.654)]) == "0.654")

test "format_nullptr":
    assert(formatted("{}", [arg_nullptr()]) == formatted("{:p}", [arg_u64(0)]))

## struct C { int i; } with a Formatter<FormatString> formatting it as "C(i={})".
struct FormatTestC:
    var i: i32

## __format_value<C>.
func format_value_format_test_c(params: TypeErasedFormatParams*, builder: FormatBuilder*, parser: FormatParser*, value: const void*?) -> !:
    var formatter = standard_formatter_create()
    standard_formatter_parse(&formatter, params, parser)
    let c_value = (const FormatTestC*)format_value_target(value)
    try formatter_format_string_format(&formatter, builder, sv("C(i={})"), [arg_i64((i64)c_value.i)])

test "use_format_string_formatter":
    let c_value = FormatTestC(i = 42)
    assert(formatted("{:*<10}", [arg_custom(&c_value, format_value_format_test_c)]) == "C(i=42)***")

test "long_long_regression":
    assert(formatted("{}", [arg_i64(0x0123456789abcdef)]) == "81985529216486895")

    var builder: StringBuilder
    string_builder_construct(&builder)
    var fmtbuilder = FormatBuilder(m_builder = &builder)
    format_builder_put_i64(&fmtbuilder, 0x0123456789abcdef) else trap("MUST")

    assert(text_of(string_builder_string_view(&builder)) == "81985529216486895")

test "hex_dump":
    assert(formatted("{:hex-dump}", [lit("0000")]) == "30303030")
    assert(formatted("{:>4hex-dump}", [lit("0000")]) == "30303030    0000")
    assert(formatted("{:>2hex-dump}", [lit("0000")]) == "3030    00\n3030    00")
    assert(formatted("{:*>4hex-dump}", [lit("0000")]) == "30303030****0000")

## An `int` element for Formatter<ReadonlySpan<int>>.
func span_element_i32(element: const void*) -> TypeErasedParameter:
    return arg_i64((i64)*(const i32*)element)

## A StringView element for Formatter<ReadonlySpan<StringView>>.
func span_element_string_view(element: const void*) -> TypeErasedParameter:
    return arg_string_view(*(const StringView*)element)

## __format_value<ReadonlySpan<int>>: `value` points at a `const i32[]`.
func format_value_i32_span(params: TypeErasedFormatParams*, builder: FormatBuilder*, parser: FormatParser*, value: const void*?) -> !:
    let span = *(const (const i32[])*)format_value_target(value)
    var formatter = standard_formatter_create()
    standard_formatter_parse(&formatter, params, parser)
    try formatter_span_format(&formatter, builder, (const void*?)span.data, span.length, memory.size_of(i32), span_element_i32)

## __format_value<ReadonlySpan<StringView>>: `value` points at a `const StringView[]`.
func format_value_string_view_span(params: TypeErasedFormatParams*, builder: FormatBuilder*, parser: FormatParser*, value: const void*?) -> !:
    let span = *(const (const StringView[])*)format_value_target(value)
    var formatter = standard_formatter_create()
    standard_formatter_parse(&formatter, params, parser)
    try formatter_span_format(&formatter, builder, (const void*?)span.data, span.length, memory.size_of(StringView), span_element_string_view)

## A ReadonlySpan<StringView> element for Formatter<ReadonlySpan<ReadonlySpan<StringView>>>.
func span_element_string_view_span(element: const void*) -> TypeErasedParameter:
    return arg_custom(element, format_value_string_view_span)

## __format_value<ReadonlySpan<ReadonlySpan<StringView>>>.
func format_value_string_view_span_span(params: TypeErasedFormatParams*, builder: FormatBuilder*, parser: FormatParser*, value: const void*?) -> !:
    let span = *(const (const (const StringView[])[])*)format_value_target(value)
    var formatter = standard_formatter_create()
    standard_formatter_parse(&formatter, params, parser)
    try formatter_span_format(&formatter, builder, (const void*?)span.data, span.length, memory.size_of(const StringView[]), span_element_string_view_span)

test "span_format":
    let ints: i32[4] = [1, 2, 3, 4]
    let int_span: const i32[] = ints
    assert(formatted("{}", [arg_custom(&int_span, format_value_i32_span)]) == "[ 1, 2, 3, 4 ]")

    let views: StringView[4] = [sv("1"), sv("2"), sv("3"), sv("4")]
    let view_span: const StringView[] = views
    assert(formatted("{}", [arg_custom(&view_span, format_value_string_view_span)]) == "[ 1, 2, 3, 4 ]")

    let first: StringView[2] = [sv("1"), sv("2")]
    let second: StringView[2] = [sv("3"), sv("4")]
    let nested: (const StringView[])[2] = [first, second]
    let nested_span: const (const StringView[])[] = nested
    assert(formatted("{}", [arg_custom(&nested_span, format_value_string_view_span_span)]) == "[ [ 1, 2 ], [ 3, 4 ] ]")

## __format_value<Vector<int>>: Formatter<Vector<T>> formats the vector's span.
func format_value_i32_vector(params: TypeErasedFormatParams*, builder: FormatBuilder*, parser: FormatParser*, value: const void*?) -> !:
    let vector = (const Vector[i32]*)format_value_target(value)
    var formatter = standard_formatter_create()
    standard_formatter_parse(&formatter, params, parser)
    try formatter_span_format(&formatter, builder, (const void*?)vector.m_outline_buffer, vector_size(vector), memory.size_of(i32), span_element_i32)

test "vector_format":
    var v: Vector[i32]
    for i: i32 in 1..=4:
        vector_append_t(&v, i)
    assert(formatted("{}", [arg_custom(&v, format_value_i32_vector)]) == "[ 1, 2, 3, 4 ]")

test "format_utf32":
    let a: u32 = 0x61
    let ladybug: u32 = 0x1f41e
    assert(formatted("{}", [arg_custom(&a, format_value_char32)]) == "a")
    assert(formatted("{}", [arg_custom(&ladybug, format_value_char32)]) == "\u{1F41E}")
    assert(formatted("{:x}", [arg_custom(&a, format_value_char32)]) == "61")
    assert(formatted("{:x}", [arg_custom(&ladybug, format_value_char32)]) == "1f41e")

    assert(formatted("{:d}", [arg_custom(&a, format_value_char32)]) == "97")
    assert(formatted("{:d}", [arg_custom(&ladybug, format_value_char32)]) == "128030")

    assert(formatted("{:6}", [arg_custom(&a, format_value_char32)]) == "a     ")
    assert(formatted("{:6d}", [arg_custom(&a, format_value_char32)]) == "    97")
    assert(formatted("{:#x}", [arg_custom(&ladybug, format_value_char32)]) == "0x1f41e")

test "format_checked":
    let hundred_i32 = Checked[i32](m_value = 100, m_overflow = false)
    assert(formatted("{}", [arg_custom(&hundred_i32, format_value_checked_i32)]) == "100")
    let hundred_u32 = Checked[u32](m_value = 100, m_overflow = false)
    assert(formatted("{}", [arg_custom(&hundred_u32, format_value_checked_u32)]) == "100")
    let negative_i32 = Checked[i32](m_value = -1234, m_overflow = false)
    assert(formatted("{}", [arg_custom(&negative_i32, format_value_checked_i32)]) == "-1234")

    var c_i8 = Checked[i8](m_value = 127, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_i8, format_value_checked_i8)]) == "127")
    # r01 ports Checked arithmetic for i32, i64, u32, u64 and usize only: overflow as `+= 100` does.
    c_i8.m_overflow = true
    assert(formatted("{}", [arg_custom(&c_i8, format_value_checked_i8)]) == "{ OVERFLOW }")

    var c_i16 = Checked[i16](m_value = 32767, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_i16, format_value_checked_i16)]) == "32767")
    # r01 ports Checked arithmetic for i32, i64, u32, u64 and usize only: overflow as `+= 100` does.
    c_i16.m_overflow = true
    assert(formatted("{}", [arg_custom(&c_i16, format_value_checked_i16)]) == "{ OVERFLOW }")

    var c_i32 = Checked[i32](m_value = 2147483647, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_i32, format_value_checked_i32)]) == "2147483647")
    checked_add_i32(&c_i32, 100)
    assert(formatted("{}", [arg_custom(&c_i32, format_value_checked_i32)]) == "{ OVERFLOW }")

    var c_i64 = Checked[i64](m_value = 9223372036854775807, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_i64, format_value_checked_i64)]) == "9223372036854775807")
    checked_add_i64(&c_i64, 100)
    assert(formatted("{}", [arg_custom(&c_i64, format_value_checked_i64)]) == "{ OVERFLOW }")

    var c_u8 = Checked[u8](m_value = 255, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_u8, format_value_checked_u8)]) == "255")
    # r01 ports Checked arithmetic for i32, i64, u32, u64 and usize only: overflow as `+= 100` does.
    c_u8.m_overflow = true
    assert(formatted("{}", [arg_custom(&c_u8, format_value_checked_u8)]) == "{ OVERFLOW }")

    var c_u16 = Checked[u16](m_value = 65535, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_u16, format_value_checked_u16)]) == "65535")
    # r01 ports Checked arithmetic for i32, i64, u32, u64 and usize only: overflow as `+= 100` does.
    c_u16.m_overflow = true
    assert(formatted("{}", [arg_custom(&c_u16, format_value_checked_u16)]) == "{ OVERFLOW }")

    var c_u32 = Checked[u32](m_value = 4294967295, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_u32, format_value_checked_u32)]) == "4294967295")
    checked_add_u32(&c_u32, 100)
    assert(formatted("{}", [arg_custom(&c_u32, format_value_checked_u32)]) == "{ OVERFLOW }")

    var c_u64 = Checked[u64](m_value = 18446744073709551615, m_overflow = false)
    assert(formatted("{}", [arg_custom(&c_u64, format_value_checked_u64)]) == "18446744073709551615")
    checked_add_u64(&c_u64, 100)
    assert(formatted("{}", [arg_custom(&c_u64, format_value_checked_u64)]) == "{ OVERFLOW }")

## ByteString::formatted(fmtstr, duration) against `expected` (TEST_CASE(format_duration)).
func expect_duration_formatted(fmtstr: str, duration: Duration, expected: str):
    assert(formatted(fmtstr, [arg_custom(&duration, format_value_duration)]) == expected)

test "format_duration":
    expect_duration_formatted("{}", duration_from_seconds(0), "0")
    expect_duration_formatted("{}", duration_from_seconds(9223372036854775807), "9223372036854775807")
    expect_duration_formatted("{}", duration_from_seconds(-9223372036854775808), "-9223372036854775808")
    expect_duration_formatted("{}", duration_from_microseconds(6500), "0.0065")
    expect_duration_formatted("{}", duration_from_microseconds(-6500), "-0.0065")
    expect_duration_formatted("{}", duration_from_milliseconds(-1500), "-1.5")
    expect_duration_formatted("{}", duration_from_nanoseconds(1), "0.000000001")
    expect_duration_formatted("{}", duration_from_nanoseconds(999999999), "0.999999999")
    expect_duration_formatted("{}", duration_from_nanoseconds(-999999999), "-0.999999999")
    expect_duration_formatted("{:05}", duration_from_seconds(1), "00001")
    expect_duration_formatted("{:8}", duration_from_milliseconds(1250), "    1.25")
    expect_duration_formatted("{:|>4}", duration_from_seconds(1), "|||1")
    expect_duration_formatted("{:.<20}", duration_from_nanoseconds(1050250000001), "1050.250000001......")
    expect_duration_formatted("{:^5}", duration_from_milliseconds(1500), " 1.5 ")
    expect_duration_formatted("{:^+6}", duration_from_milliseconds(1500), " +1.5 ")
    expect_duration_formatted("{:.10}", duration_from_milliseconds(100000500), "100000.5000000000")
    expect_duration_formatted("{:.0}", duration_from_milliseconds(67500), "67")
    expect_duration_formatted("{:.0}", duration_from_nanoseconds(123456789), "0")
    expect_duration_formatted("{:.3}", duration_from_nanoseconds(123456789), "0.123")
    expect_duration_formatted("{:.9}", duration_from_milliseconds(500), "0.500000000")
    expect_duration_formatted("{:.21}", duration_from_milliseconds(500), "0.500000000000000000000")
    expect_duration_formatted("{:#}", duration_from_milliseconds(12054), "12.054s")
    expect_duration_formatted("{:^#8}", duration_from_milliseconds(1512), " 1.512s ")