Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.0

0.6.0 / src / ak / tests_format.lucb

#==============================================================================================
#
#   tests_format - tests of the format fragments (AK::Format)
#
#   DESCRIPTION:
#       Port of Tests/AK/TestFormat.cpp (Ladybird 47c82b38d0), and focused tests of the
#       format helpers.
#
#       `ByteString::formatted(fmt, args...)` is `formatted(fmt, [args...])` below: the text
#       vformat writes. A C++ string literal argument is a `char const*` (arg_c_string via
#       lit); an `int` is signed, a `u`-suffixed or size_t literal unsigned, as the C++
#       overloads pick them.
#
#       Not ported: is_integral_works_properly (a C++ type trait). The span_format case with
#       Vector<Vector<ByteString>> uses spans of StringView spans: Formatter<ByteString> is
#       Formatter<StringView>.
#
#==============================================================================================

# mark: Helpers =================================================================================

## ByteString::formatted(fmtstr, arguments...): the text `fmtstr` formats to.
func formatted(fmtstr: str, arguments: const TypeErasedParameter[]) -> str:
    var builder: StringBuilder
    string_builder_construct(&builder)
    vformat_arguments(&builder, sv(fmtstr), arguments) else trap("MUST: vformat")
    let view = string_builder_string_view(&builder)
    # A short result lives in the builder's inline buffer, in this frame: copy it out.
    let bytes = string_view_bytes(&view)
    let copy = new u8[bytes.length] --- else trap("out of memory")
    memory.copy(copy, bytes, bytes.length)
    return (str)copy

## No format arguments.
func no_arguments() -> const TypeErasedParameter[]:
    var empty: const TypeErasedParameter[]
    return empty

## A C++ string literal argument: a `char const*`.
func lit(text: str) -> TypeErasedParameter:
    return arg_c_string(text.bytes.data)

## The text of a StringView.
func text_of(view: StringView) -> str:
    return (str)string_view_bytes(&view)

# mark: Focused tests ==========================================================================

test "convert_unsigned_to_string":
    var buffer: u8[128]
    let zero_length = convert_unsigned_to_string(0, &buffer, 10, false, false)
    assert((str)buffer[0..<zero_length] == "0")
    let decimal_length = convert_unsigned_to_string(1234567, &buffer, 10, false, true)
    assert((str)buffer[0..<decimal_length] == "1,234,567")
    let hex_length = convert_unsigned_to_string(0xbeef, &buffer, 16, true, false)
    assert((str)buffer[0..<hex_length] == "BEEF")
    let binary_length = convert_unsigned_to_string(~(u64)0, &buffer, 2, false, true)
    # 64 digits and 21 separators: the worst case the 128-byte buffer is sized for.
    assert(binary_length == 85)

test "integral_helpers":
    assert(pow_integral_u64(5, 0) == 1)
    assert(pow_integral_u64(5, 3) == 125)
    # Wraps as C++'s unsigned arithmetic does: 5^30 mod 2^64.
    assert(pow_integral_u64(5, 30) == 8985370930000934825)
    assert(log2_u8(2) == 1)
    assert(log2_u8(8) == 3)
    assert(log2_u8(16) == 4)

test "type_erased_parameters":
    let parameters = [arg_u64(7), arg_i64(3), arg_bool(true)]
    var params = type_erased_format_params_create(parameters)
    assert(type_erased_format_params_parameters(&params).length == 3)
    assert(type_erased_format_params_take_next_index(&params) == 0)
    assert(type_erased_format_params_take_next_index(&params) == 1)
    assert(type_erased_parameter_to_size(&parameters[0]) == 7)
    assert(type_erased_parameter_to_size(&parameters[1]) == 3)
    var empty = type_erased_format_params_create(no_arguments())
    assert(type_erased_format_params_parameters(&empty).length == 0)

# mark: TestFormat.cpp ==========================================================================

test "format_string_literals":
    assert(formatted("prefix-{}-suffix", [lit("abc")]) == "prefix-abc-suffix")
    assert(formatted("{}{}{}", [lit("a"), lit("b"), lit("c")]) == "abc")

test "format_integers":
    assert(formatted("{}", [arg_u64(42)]) == "42")
    assert(formatted("{:4}", [arg_u64(42)]) == "  42")
    assert(formatted("{:08}", [arg_u64(42)]) == "00000042")
    assert(formatted("{:7}", [arg_i64(-17)]) == "    -17")
    assert(formatted("{}", [arg_i64(-17)]) == "-17")
    assert(formatted("{:04}", [arg_i64(13)]) == "0013")
    assert(formatted("{:08x}", [arg_i64(4096)]) == "00001000")
    assert(formatted("{:x}", [arg_u64(0x1111222233334444)]) == "1111222233334444")
    assert(formatted("{:4}", [arg_i64(12345678)]) == "12345678")
    assert(formatted("{}", [arg_i64(-9223372036854775808)]) == "-9223372036854775808")
    assert(formatted("{:x}", [arg_i64(-9223372036854775808)]) == "-8000000000000000")
    assert(formatted("{:'}", [arg_i64(0)]) == "0")
    assert(formatted("{:'}", [arg_i64(4096)]) == "4,096")
    assert(formatted("{:'}", [arg_i64(16777216)]) == "16,777,216")
    assert(formatted("{:'}", [arg_u64(~(u64)0)]) == "18,446,744,073,709,551,615")
    assert(formatted("{:'}", [arg_u64(~(u64)0)]) == "18,446,744,073,709,551,615")
    assert(formatted("{:'}", [arg_i64(-9223372036854775807)]) == "-9,223,372,036,854,775,807")
    assert(formatted("{:'x}", [arg_i64(0)]) == "0")
    assert(formatted("{:'x}", [arg_i64(16777216)]) == "1,000,000")
    assert(formatted("{:'x}", [arg_u64(~(u64)0)]) == "f,fff,fff,fff,fff,fff")
    assert(formatted("{:'x}", [arg_i64(-9223372036854775807)]) == "-7,fff,fff,fff,fff,fff")
    assert(formatted("{:'b}", [arg_u64(~(u64)0)]) == "1,111,111,111,111,111,111,111,111,111,111,111,111,111,111,111,111,111,111,111,111,111")

test "reorder_format_arguments":
    assert(formatted("{1}{0}", [lit("a"), lit("b")]) == "ba")
    assert(formatted("{0}{1}", [lit("a"), lit("b")]) == "ab")
    # Compiletime check bypass: ignoring a passed argument.
    assert(formatted("{0}{0}{0}", [lit("a"), lit("b")]) == "aaa")
    # Compiletime check bypass: ignoring a passed argument.
    assert(formatted("{1}{}{0}", [lit("a"), lit("b"), lit("c")]) == "baa")

test "escape_braces":
    assert(formatted("{{{}", [lit("foo")]) == "{foo")
    assert(formatted("{}}}", [lit("bar")]) == "bar}")

test "everything":
    assert(formatted("{{{:04}/{}/{0:8}/{1}", [arg_u64(42), lit("foo")]) == "{0042/foo/      42/foo")

test "string_builder":
    var builder: StringBuilder
    string_builder_construct(&builder)
    vformat_arguments(&builder, sv(" {}  "), [arg_i64(42)]) else trap("MUST")
    vformat_arguments(&builder, sv("{1}{0} "), [arg_i64(1), arg_i64(2)]) else trap("MUST")

    assert(text_of(string_builder_string_view(&builder)) == " 42  21 ")

test "format_without_arguments":
    assert(formatted("foo", no_arguments()) == "foo")

test "format_upper_case_integer":
    assert(formatted("{:4X}", [arg_i64(0xff)]) == "  FF")
    assert(formatted("{:#4X}", [arg_i64(0xff)]) == "0XFF")

    assert(formatted("{:b}", [arg_i64(0xff)]) == "11111111")
    assert(formatted("{:B}", [arg_i64(0xff)]) == "11111111")
    assert(formatted("{:#b}", [arg_i64(0xff)]) == "0b11111111")

test "format_aligned":
    assert(formatted("{:*<8}", [arg_i64(13)]) == "13******")
    assert(formatted("{:*^8}", [arg_i64(13)]) == "***13***")
    assert(formatted("{:*>8}", [arg_i64(13)]) == "******13")
    assert(formatted("{:*>+8}", [arg_i64(13)]) == "*****+13")
    assert(formatted("{:*^ 8}", [arg_i64(13)]) == "** 13***")

test "format_octal":
    assert(formatted("{:o}", [arg_i64(0o744)]) == "744")
    assert(formatted("{:#o}", [arg_i64(0o744)]) == "0744")
    assert(formatted("{:'o}", [arg_i64(0o54321)]) == "54,321")
    assert(formatted("{:'o}", [arg_i64(0o567012340)]) == "567,012,340")

test "zero_pad":
    assert(formatted("{: <010}", [arg_i64(42)]) == "42        ")
    assert(formatted("{:010}", [arg_i64(42)]) == "0000000042")
    assert(formatted("{:/^010}", [arg_i64(42)]) == "////42////")
    assert(formatted("{:04x}", [arg_i64(-32)]) == "-0020")
    assert(formatted("{:#06x}", [arg_i64(-64)]) == "-0x000040")

test "replacement_field":
    assert(formatted("{:*>{1}}", [arg_i64(13), arg_u64(10)]) == "********13")
    assert(formatted("{:*<{1}}", [arg_i64(7), arg_i64(4)]) == "7***")
    # Compiletime check bypass: intentionally ignoring extra arguments
    assert(formatted("{:{2}}", [arg_i64(-5), arg_i64(8), arg_i64(16)]) == "              -5")
    assert(formatted("{{{:*^{1}}}}", [arg_i64(1), arg_i64(3)]) == "{*1*}")
    assert(formatted("{:0{}}", [arg_i64(1), arg_i64(3)]) == "001")

test "replacement_field_regression":
    assert(formatted("{:{}}", [lit(""), arg_u64(6)]) == "      ")

test "complex_string_specifiers":
    assert(formatted("{:.8}", [lit("123456789")]) == "12345678")
    assert(formatted("{:9}", [lit("abcd")]) == "abcd     ")
    assert(formatted("{:>9}", [lit("abcd")]) == "     abcd")
    assert(formatted("{:^9}", [lit("abcd")]) == "  abcd   ")
    assert(formatted("{:4.6}", [lit("a")]) == "a   ")
    assert(formatted("{:4.6}", [lit("abcdef")]) == "abcdef")
    assert(formatted("{:4.6}", [lit("abcdefghi")]) == "abcdef")

test "cast_integer_to_character":
    assert(formatted("{:c}", [arg_i64(97)]) == "a")
    assert(formatted("{:c}", [arg_u64(102)]) == "f")

test "boolean_values":
    assert(formatted("{}", [arg_bool(true)]) == "true")
    assert(formatted("{}", [arg_bool(false)]) == "false")
    assert(formatted("{:6}", [arg_bool(true)]) == "true  ")
    assert(formatted("{:>4}", [arg_bool(false)]) == "false")
    assert(formatted("{:d}", [arg_bool(false)]) == "0")
    assert(formatted("{:d}", [arg_bool(true)]) == "1")
    assert(formatted("{:#08x}", [arg_bool(true)]) == "0x00000001")

test "pointers":
    let ptr = (const void*?)(usize)0x4000

    # sizeof(void*) == 8 on every luce-base native target.
    assert(formatted("{:p}", [arg_i64(32)]) == "0x0000000000000020")
    assert(formatted("{:p}", [arg_pointer(ptr)]) == "0x0000000000004000")
    assert(formatted("{}", [arg_pointer(ptr)]) == "0x0000000000004000")

# If the format implementation did absolutely nothing, all tests would pass. This
# is because when a test fails we only write "FAIL" to stdout using format.
#
# This is a bit scary, thus this test. At least this test should fail in this case.
test "ensure_that_format_works":
    if formatted("FAIL", no_arguments()) != "FAIL":
        trap("FAIL")

    if formatted("{} FAIL {}", [arg_i64(1), arg_i64(2)]) != "1 FAIL 2":
        trap("FAIL")

test "format_string_literal_as_pointer":
    let literal = "abc"
    assert(formatted("{:p}", [lit(literal)]) == formatted("{:p}", [arg_u64((u64)(usize)literal.bytes.data)]))

test "format_character":
    let a: u8 = 'a'
    assert(formatted("{}", [arg_char(a)]) == "a")

## struct A {}: a type without a Formatter.
struct FormatTestA:
    var unused: u8

## struct B {} with `Formatter<B> : Formatter<StringView>` formatting it as "B".
struct FormatTestB:
    var unused: u8

## __format_value<B>.
func format_value_format_test_b(params: TypeErasedFormatParams*, builder: FormatBuilder*, parser: FormatParser*, value: const void*?) -> !:
    var formatter = standard_formatter_create()
    standard_formatter_parse(&formatter, params, parser)
    try formatter_string_view_format(&formatter, builder, sv("B"))

test "format_if_supported":
    let a = FormatTestA(unused = 0)
    var a_if_supported: FormatIfSupported[u8] = ---
    format_if_supported_construct(&a_if_supported, &a.unused)
    assert(formatted("{}", [arg_custom(&a_if_supported, format_value_format_if_supported)]) == "?")
    # FormatIfSupported { B {} }: B has a formatter, so its own formatter formats it.
    let b = FormatTestB(unused = 0)
    assert(formatted("{}", [arg_custom(&b, format_value_format_test_b)]) == "B")

extern func tmpfile() -> SFile*?
extern func rewind(stream: SFile*?)
extern func fread(ptr: void*, size: usize, count: usize, stream: SFile*?) -> usize
extern func fclose(stream: SFile*?) -> i32

test "file_descriptor":
    let file = tmpfile()

    # outln(file, "{}", "Hello, World!");
    var params = type_erased_format_params_create([lit("Hello, World!")])
    vout(file, sv("{}"), &params, true)
    out_s_file(file, "foo")
    outln_s_file(file, "bar")

    rewind(file)

    var buffer: u8[256]
    let nread = fread(&buffer[0], 1, buffer.length, file)

    assert((str)buffer[0..<nread] == "Hello, World!\nfoobar\n")

    _ = fclose(file)