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(¶ms).length == 3)
assert(type_erased_format_params_take_next_index(¶ms) == 0)
assert(type_erased_format_params_take_next_index(¶ms) == 1)
assert(type_erased_parameter_to_size(¶meters[0]) == 7)
assert(type_erased_parameter_to_size(¶meters[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("{}"), ¶ms, 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)