Luce packages
LuceLuce BaseLuciaOS

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 = &parameter)
    let foo = string_vformatted(sv("Hello {}"), &params) 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")