dymokomi/luce-browser-foundation
Source of release 0.6.0
0.6.0 / src / ak / tests_string_1.lucb
#==============================================================================================
#
# tests_string_1 - the String tests, part 1: construction, streams, UTF-8/16, substrings
#
# DESCRIPTION:
# Port of Tests/AK/TestString.cpp (lines 1-321). The streams of long_streams and
# invalid_utf8 are FixedMemoryStream and AllocatingMemoryStream in the donor (region r01);
# here a small test stream over a byte span feeds String::from_stream the same bytes.
# The EXPECT_DEATH checks are not ported (a trap ends the test run), nor are the
# to_lowercase/to_uppercase/to_titlecase/to_casefold tests (lines 323-750): those String
# members live in LibUnicode, not AK.
#
#==============================================================================================
# mark: Helpers =================================================================================
## A read-only Stream over a byte span: the stand-in for the donor's memory streams.
struct StringTestStream:
var stream_base: Stream
var bytes: const u8[]
var offset: usize
## StringTestStream's read_until_filled: copies the next bytes, failing past the end.
func string_test_stream_read_until_filled(base: Stream*, buffer: u8[]) -> !:
let this = (StringTestStream*)base
if this.offset + buffer.length > this.bytes.length:
error(ak_error, "StringTestStream: not enough data")
copy_bytes(buffer, this.bytes[this.offset..<this.offset + buffer.length])
this.offset += buffer.length
## The vtable of StringTestStream.
let string_test_stream_vtable: StreamVTable = StreamVTable(class_info = &string_test_stream_class, read_until_filled = string_test_stream_read_until_filled)
## Class information of StringTestStream.
let string_test_stream_class: ClassInfo = ClassInfo(name = "StringTestStream", first_id = 0, last_id = 0, size = memory.size_of(StringTestStream), vtable = (const void*)&string_test_stream_vtable)
## A StringTestStream over `bytes`.
func string_test_stream(bytes: const u8[]) -> StringTestStream:
return StringTestStream(stream_base = Stream(vtable = &string_test_stream_vtable, class_id = 0), bytes = bytes, offset = 0)
## `EXPECT_EQ(string, "text"sv)`.
func string_is(string: const String*, text: str) -> bool:
return string_eq_string_view(string, sv(text))
## Whether a failed String creation reported `message`.
func string_error_contains(failure: Error, message: str) -> bool:
let view = sv(failure.message)
return string_view_contains_string_view(&view, sv(message))
# mark: Tests ===================================================================================
test "short_ascii_literal_is_constexpr":
# The _string UDL folds short ASCII literals to a compile-time constant.
let s = string_from_str("foo")
assert(string_is(&s, "foo"))
assert(string_base_bytes(&s.string_base).length == 3)
test "construct_empty":
let empty = string_new()
assert(string_is_empty(&empty))
assert(string_base_bytes(&empty.string_base).length == 0)
assert(string_is(&empty, ""))
let empty2 = string_from_str("")
assert(string_is_empty(&empty2))
assert(string_equals(&empty, &empty2))
let empty3 = string_from_utf8(sv("")) else trap("MUST")
assert(string_is_empty(&empty3))
assert(string_equals(&empty, &empty3))
test "move_assignment":
var string1 = string_from_str("hello")
string1 = string_from_str("friends!")
assert(string_is(&string1, "friends!"))
## The `test` lambda of copy_assignment.
func string_copy_assignment(first: String, second: String):
var string1 = first
string1 = second
assert(string_equals(&string1, &second))
test "copy_assignment":
string_copy_assignment(string_new(), string_new())
string_copy_assignment(string_new(), string_from_str("abc"))
string_copy_assignment(string_new(), string_from_str("long string"))
string_copy_assignment(string_from_str("abc"), string_new())
string_copy_assignment(string_from_str("abc"), string_from_str("abc"))
string_copy_assignment(string_from_str("abc"), string_from_str("long string"))
string_copy_assignment(string_from_str("long string"), string_new())
string_copy_assignment(string_from_str("long string"), string_from_str("abc"))
string_copy_assignment(string_from_str("long string"), string_from_str("long string"))
test "short_strings":
# NOTE: make sure that the test strings' first character has an even ASCII code. This is
# important for the odd pointer address checks (this is to test if the ShortString
# structs are endian agnostic).
let string1 = string_from_utf8(sv("foo bar")) else trap("MUST")
assert(string_base_is_short_string(&string1.string_base) == true)
assert(string_base_bytes(&string1.string_base).length == 7)
let view1 = string_bytes_as_string_view(&string1)
assert(string_view_equals(&view1, "foo bar"))
# check for odd "pointer" value, i.e. short string flag
assert(string_base_raw_string(&string1.string_base) % 2 == 1)
let string2 = string_from_str("foo bar")
assert(string_base_is_short_string(&string2.string_base) == true)
assert(string_base_bytes(&string2.string_base).length == 7)
assert(string_equals(&string2, &string1))
# check for odd "pointer" value, i.e. short string flag
assert(string_base_raw_string(&string2.string_base) % 2 == 1)
test "long_strings":
let string = string_from_utf8(sv("abcdefgh")) else trap("MUST")
assert(string_base_is_short_string(&string.string_base) == false)
assert(string_base_bytes(&string.string_base).length == 8)
let view = string_bytes_as_string_view(&string)
assert(string_view_equals(&view, "abcdefgh"))
test "long_streams":
let test_view = sv("Well, hello friends")
var stream1 = string_test_stream(string_view_bytes(&test_view))
let string1 = string_from_stream(&stream1.stream_base, string_view_length(&test_view)) else trap("MUST")
assert(string_base_is_short_string(&string1.string_base) == false)
assert(string_base_bytes(&string1.string_base).length == 19)
assert(string_eq_string_view(&string1, test_view))
var stream2 = string_test_stream("abc".bytes)
let string2 = string_from_stream(&stream2.stream_base, 3) else trap("MUST")
assert(string_base_is_short_string(&string2.string_base) == true)
assert(string_base_bytes(&string2.string_base).length == 3)
assert(string_is(&string2, "abc"))
var stream3 = string_test_stream("0123456789".bytes)
let string3 = string_from_stream(&stream3.stream_base, 9) else trap("MUST")
assert(string_base_is_short_string(&string3.string_base) == false)
assert(string_base_bytes(&string3.string_base).length == 9)
assert(string_is(&string3, "012345678"))
# The donor writes the u32 0xffffffff three times.
var stream4 = string_test_stream(b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff")
var is_error = false
_ = string_from_stream(&stream4.stream_base, 12) catch:
is_error = true
recover string_new()
assert(is_error == true)
test "invalid_utf8":
var message_ok = false
# U+110000
_ = string_from_utf8(string_view_from_bytes(b"long string \xf4\x8f\xbf\xc0")) catch failure:
message_ok = string_error_contains(failure, "Input was not valid UTF-8")
recover string_new()
assert(message_ok)
message_ok = false
# U+121C3D
_ = string_from_utf8(string_view_from_bytes(b"\xf4\xa1\xb0\xbd")) catch failure:
message_ok = string_error_contains(failure, "Input was not valid UTF-8")
recover string_new()
assert(message_ok)
var stream = string_test_stream(b"\xf4\xa1\xb0\xbd")
message_ok = false
_ = string_from_stream(&stream.stream_base, 4) catch failure:
message_ok = string_error_contains(failure, "Input was not valid UTF-8")
recover string_new()
assert(message_ok)
test "with_replacement_character":
let string1 = string_from_utf8_with_replacement_character(string_view_from_bytes(b"long string \xf4\x8f\xbf\xc0"), StringWithBomHandling.no) # U+110000
let string1_expected: u8[24] = [0x6c, 0x6f, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd]
assert(compare_bytes(string_base_bytes(&string1.string_base), string1_expected) == 0)
assert(string_base_bytes(&string1.string_base).length == 24)
let string3 = string_from_utf8_with_replacement_character(sv("A valid string!"), StringWithBomHandling.no)
assert(string_is(&string3, "A valid string!"))
let string4 = string_from_utf8_with_replacement_character(sv(""), StringWithBomHandling.no)
assert(string_is(&string4, ""))
let string5 = string_from_utf8_with_replacement_character(sv("\u{feff}WHF!"), StringWithBomHandling.yes)
assert(string_is(&string5, "WHF!"))
let string6 = string_from_utf8_with_replacement_character(sv("\u{feff}WHF!"), StringWithBomHandling.no)
assert(string_is(&string6, "\u{feff}WHF!"))
let string7 = string_from_utf8_with_replacement_character(string_view_from_bytes(b"\xed\xa0\x80WHF!")) # U+D800
assert(string_is(&string7, "\u{fffd}WHF!"))
test "from_utf16_be_with_replacement_character":
# UTF-16 BE for "A" is 0x00 0x41
let valid_be: u8[2] = [0x00, 0x41]
let string1 = string_from_utf16_be_with_replacement_character(valid_be) else trap("MUST")
assert(string_is(&string1, "A"))
# Invalid surrogate pair in BE: high surrogate 0xD800 without low surrogate
# In BE: 0xD8 0x00
let invalid_be: u8[2] = [0xd8, 0x00]
let string2 = string_from_utf16_be_with_replacement_character(invalid_be) else trap("MUST")
assert(string_is(&string2, "\u{fffd}"))
# Same bytes interpreted as LE would be 0x00D8 which is valid (U+00D8 = Ø)
let string3 = string_from_utf16_le_with_replacement_character(invalid_be) else trap("MUST")
assert(string_is(&string3, "Ø"))
test "from_code_points":
for code_point: u32 in 0..<0x80:
let string = string_from_code_point(code_point)
var ch: u8[1] = [(u8)code_point]
let view = string_view_from_bytes(ch)
assert(string_eq_string_view(&string, view))
let string = string_from_code_point(0x10ffff)
assert(string_eq_string_view(&string, string_view_from_bytes(b"\xf4\x8f\xbf\xbf")))
test "substring":
let superstring = string_from_str("Hello I am a long string")
let short_substring = string_substring_from_byte_offset_usize(&superstring, 0, 5) else trap("MUST")
assert(string_is(&short_substring, "Hello"))
let long_substring = string_substring_from_byte_offset_usize(&superstring, 0, 10) else trap("MUST")
assert(string_is(&long_substring, "Hello I am"))
test "substring_with_shared_superstring":
let superstring = string_from_str("Hello I am a long string")
let substring1 = string_substring_from_byte_offset_with_shared_superstring_usize(&superstring, 0, 5) else trap("MUST")
assert(string_is(&substring1, "Hello"))
let substring2 = string_substring_from_byte_offset_with_shared_superstring_usize(&superstring, 0, 10) else trap("MUST")
assert(string_is(&substring2, "Hello I am"))
test "code_points":
let string = string_from_str("🦬🪒")
var code_points: u32[2]
var count: usize = 0
let view = string_code_points(&string)
var it = utf8_view_begin(&view)
while not utf8_code_point_iterator_done(&it):
code_points[count] = utf8_code_point_iterator_deref(&it)
count += 1
_ = utf8_code_point_iterator_inc(&it)
assert(count == 2)
assert(code_points[0] == 0x1f9ac)
assert(code_points[1] == 0x1fa92)
test "string_builder":
var builder = string_builder_new()
string_builder_append_code_point(&builder, 0x1f9ac)
string_builder_append_code_point(&builder, 0x1fa92)
let string = string_builder_to_string(&builder) else trap("MUST")
assert(string_is(&string, "🦬🪒"))
assert(string_base_bytes(&string.string_base).length == 8)
test "ak_format":
# String::formatted("Hello {}", "friends"_string): the argument goes in as a string view.
var parameter: TypeErasedParameter
parameter.value.as_string_view = sv("friends")
parameter.type_ = TypeErasedParameterType.string_view
var params = TypeErasedFormatParams(m_size = 1, m_next_index = 0, m_parameters = ¶meter)
let foo = string_vformatted(sv("Hello {}"), ¶ms) else trap("MUST")
assert(string_is(&foo, "Hello friends"))
test "replace":
let haystack = string_from_str("Hello enemies")
let result1 = string_replace(&haystack, sv("enemies"), sv("friends"), ReplaceMode.all) else trap("MUST")
assert(string_is(&result1, "Hello friends"))
let base_title = string_from_str("anon@courage:~")
let result2 = string_replace(&base_title, sv("[*]"), sv("(*)"), ReplaceMode.first_only) else trap("MUST")
assert(string_is(&result2, "anon@courage:~"))
## The `test_reverse` lambda of reverse.
func string_test_reverse(test_text: str, expected: str):
let string = string_from_utf8(sv(test_text)) else trap("MUST")
let result = string_reverse(&string) else trap("MUST")
assert(string_is(&result, expected))
test "reverse":
string_test_reverse("", "")
string_test_reverse("a", "a")
string_test_reverse("ab", "ba")
string_test_reverse("ab cd ef", "fe dc ba")
string_test_reverse("😀", "😀")
string_test_reverse("ab😀cd", "dc😀ba")