Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.0

0.6.0 / src / ak / tests_utf16_string_2.lucb

#==============================================================================================
#
#   tests_utf16_string_2 - Utf16String tests (trimming, copies, equality, iteration)
#
#   DESCRIPTION:
#       Port of Tests/AK/TestUtf16String.cpp (lines 1028-1309). Moves are copies in the port
#       (DESIGN.md ยง3.3), so move_operations keeps only the checks on the moved-to strings.
#
#==============================================================================================

## The `make_copy` helper of the donor: a new string equal to `string`.
func t16s_make_copy(string: const Utf16String*) -> Utf16String:
    if utf16_string_base_has_ascii_storage(&string.utf16_string_base):
        return utf16_string_from_utf8_string_view(utf16_string_base_ascii_view(&string.utf16_string_base))
    return utf16_string_from_utf16(t16s_view(string))

## `EXPECT_EQ(string1, string2)` for two Utf16Strings.
func t16s_equals(a: const Utf16String*, b: const Utf16String*) -> bool:
    return utf16_string_base_eq_utf16_string_base(&a.utf16_string_base, &b.utf16_string_base)

## The `expect_same_string` lambda of the trim test: equal, and the same storage.
func t16s_expect_same_string(string: const Utf16String*, trimmed: Utf16String):
    let result = &trimmed
    assert(t16s_equals(string, result))

    assert(utf16_string_base_has_ascii_storage(&string.utf16_string_base) == utf16_string_base_has_ascii_storage(&result.utf16_string_base))
    let string_view = t16s_view(string)
    let result_view = t16s_view(result)

    if utf16_string_base_has_ascii_storage(&string.utf16_string_base):
        assert(utf16_view_ascii_span(&string_view).data == utf16_view_ascii_span(&result_view).data)
    else:
        assert(utf16_view_utf16_span(&string_view).data == utf16_view_utf16_span(&result_view).data)

## `EXPECT_EQ(string.trim(code_units, mode), expected)`.
func t16s_trim_is(string: const Utf16String*, code_units: Utf16View, mode: TrimMode, expected: Utf16View) -> bool:
    let result = utf16_string_trim(string, code_units, mode)
    return t16s_eq(&result, expected)

## `string.trim(code_units, mode)`.
func t16s_trim(string: const Utf16String*, code_units: Utf16View, mode: TrimMode) -> Utf16String:
    return utf16_string_trim(string, code_units, mode)

test "trim":
    let whitespace = t16(" ")

    let string1 = t16_lit("looooong word")
    t16s_expect_same_string(&string1, t16s_trim(&string1, whitespace, TrimMode.both))
    t16s_expect_same_string(&string1, t16s_trim(&string1, whitespace, TrimMode.left))
    t16s_expect_same_string(&string1, t16s_trim(&string1, whitespace, TrimMode.right))

    let string2 = t16_lit("   looooong word")
    assert(t16s_trim_is(&string2, whitespace, TrimMode.both, t16("looooong word")))
    assert(t16s_trim_is(&string2, whitespace, TrimMode.left, t16("looooong word")))
    t16s_expect_same_string(&string2, t16s_trim(&string2, whitespace, TrimMode.right))

    let string3 = t16_lit("looooong word   ")
    assert(t16s_trim_is(&string3, whitespace, TrimMode.both, t16("looooong word")))
    t16s_expect_same_string(&string3, t16s_trim(&string3, whitespace, TrimMode.left))
    assert(t16s_trim_is(&string3, whitespace, TrimMode.right, t16("looooong word")))

    let string4 = t16_lit("   looooong word   ")
    assert(t16s_trim_is(&string4, whitespace, TrimMode.both, t16("looooong word")))
    assert(t16s_trim_is(&string4, whitespace, TrimMode.left, t16("looooong word   ")))
    assert(t16s_trim_is(&string4, whitespace, TrimMode.right, t16("   looooong word")))

    let string5 = t16_lit("   \u{180e}   ")
    assert(t16s_trim_is(&string5, whitespace, TrimMode.both, t16("\u{180e}")))
    assert(t16s_trim_is(&string5, whitespace, TrimMode.left, t16("\u{180e}   ")))
    assert(t16s_trim_is(&string5, whitespace, TrimMode.right, t16("   \u{180e}")))

    let string6 = t16_lit("๐Ÿ˜€wfh๐Ÿ˜€")
    assert(t16s_trim_is(&string6, t16("๐Ÿ˜€"), TrimMode.both, t16("wfh")))
    assert(t16s_trim_is(&string6, t16("๐Ÿ˜€"), TrimMode.left, t16("wfh๐Ÿ˜€")))
    assert(t16s_trim_is(&string6, t16("๐Ÿ˜€"), TrimMode.right, t16("๐Ÿ˜€wfh")))

    t16s_expect_same_string(&string6, t16s_trim(&string6, whitespace, TrimMode.both))
    t16s_expect_same_string(&string6, t16s_trim(&string6, whitespace, TrimMode.left))
    t16s_expect_same_string(&string6, t16s_trim(&string6, whitespace, TrimMode.right))

## The `test` lambda of copy_operations.
func t16s_test_copy_operations(string1_value: Utf16String):
    let string1 = &string1_value
    let original = t16s_make_copy(string1)

    # Copy constructor.
    let string2 = *string1

    assert(t16s_equals(string1, &original))
    assert(t16s_equals(string1, &string2))

    # Copy assignment.
    var string3 = utf16_string_new()
    string3 = *string1

    assert(t16s_equals(string1, &original))
    assert(t16s_equals(string1, &string3))

test "copy_operations":
    t16s_test_copy_operations(utf16_string_new())
    t16s_test_copy_operations(utf16_string_from_str("hello"))
    t16s_test_copy_operations(utf16_string_from_str("hello there general!"))
    t16s_test_copy_operations(utf16_string_from_str("hello ๐Ÿ˜€ there!"))

## The `test` lambda of move_operations; a move is a copy, so the moved-from checks are left out.
func t16s_test_move_operations(string1: Utf16String):
    let original = t16s_make_copy(&string1)

    # Move constructor.
    let string2 = string1

    assert(t16s_equals(&string2, &original))

    # Move assignment.
    var string3 = utf16_string_new()
    string3 = string2

    assert(t16s_equals(&string3, &original))

test "move_operations":
    t16s_test_move_operations(utf16_string_new())
    t16s_test_move_operations(utf16_string_from_str("hello"))
    t16s_test_move_operations(utf16_string_from_str("hello there general!"))
    t16s_test_move_operations(utf16_string_from_str("hello ๐Ÿ˜€ there!"))

## The `test` lambda of equals.
func t16s_test_equals(string1_value: Utf16String, inequal_value: Utf16String):
    let string1 = &string1_value
    let inequal_string = &inequal_value
    let string2 = t16s_make_copy(string1)

    assert(t16s_equals(string1, string1))
    assert(t16s_equals(string1, &string2))
    assert(t16s_equals(&string2, string1))
    assert(t16s_equals(&string2, &string2))

    if utf16_string_base_has_long_utf16_storage(&string1.utf16_string_base):
        assert(t16s_eq(string1, t16s_view(string1)))
        assert(t16s_eq(string1, t16s_view(&string2)))
        assert(t16s_eq(&string2, t16s_view(string1)))
        assert(t16s_eq(&string2, t16s_view(&string2)))

    assert(not t16s_equals(string1, inequal_string))
    assert(not t16s_equals(&string2, inequal_string))
    assert(not t16s_equals(inequal_string, string1))
    assert(not t16s_equals(inequal_string, &string2))

    if utf16_string_base_has_long_utf16_storage(&string1.utf16_string_base):
        assert(not t16s_eq(string1, t16s_view(inequal_string)))
        assert(not t16s_eq(&string2, t16s_view(inequal_string)))
        assert(not t16s_eq(inequal_string, t16s_view(string1)))
        assert(not t16s_eq(inequal_string, t16s_view(&string2)))

test "equals":
    # Short (empty) ASCII string comparison.
    t16s_test_equals(utf16_string_new(), utf16_string_from_str("hello"))

    # Short ASCII string comparison.
    t16s_test_equals(utf16_string_from_str("hello"), utf16_string_from_str("there"))

    # Short and long ASCII string comparison.
    t16s_test_equals(utf16_string_from_str("hello"), utf16_string_from_str("hello there general!"))

    # Long ASCII string comparison.
    t16s_test_equals(utf16_string_from_str("hello there!"), utf16_string_from_str("hello there general!"))

    # UTF-16 string comparison.
    t16s_test_equals(utf16_string_from_str("๐Ÿ˜€"), utf16_string_from_str("hello ๐Ÿ˜€"))

    # Short ASCII and UTF-16 string comparison.
    t16s_test_equals(utf16_string_from_str("hello"), utf16_string_from_str("๐Ÿ˜€"))

    # Short ASCII and UTF-16 string of same code unit length comparison.
    t16s_test_equals(utf16_string_from_str("ab"), utf16_string_from_str("๐Ÿ˜€"))

    # Long ASCII and UTF-16 string comparison.
    t16s_test_equals(utf16_string_from_str("hello there general!"), utf16_string_from_str("๐Ÿ˜€"))

    # Long ASCII and UTF-16 string of same code unit length comparison.
    t16s_test_equals(utf16_string_from_str("ababababab"), utf16_string_from_str("๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€"))

## The `test` lambda of equals_ascii.
func t16s_test_equals_ascii(ascii: StringView, inequal_value: Utf16String):
    let inequal_string = &inequal_value
    let string = utf16_string_from_utf8_string_view(ascii)

    assert(utf16_string_base_eq_string_view(&string.utf16_string_base, ascii))
    assert(utf16_string_base_eq_string_view(&string.utf16_string_base, ascii))

    assert(not utf16_string_base_eq_string_view(&inequal_string.utf16_string_base, ascii))
    assert(not utf16_string_base_eq_string_view(&inequal_string.utf16_string_base, ascii))

test "equals_ascii":
    # Short (empty) ASCII string comparison.
    t16s_test_equals_ascii(StringView(), utf16_string_from_str("hello"))

    # Short ASCII string comparison.
    t16s_test_equals_ascii(sv("hello"), utf16_string_from_str("there"))

    # Short and long ASCII string comparison.
    t16s_test_equals_ascii(sv("hello"), utf16_string_from_str("hello there general!"))

    # Long ASCII string comparison.
    t16s_test_equals_ascii(sv("hello there!"), utf16_string_from_str("hello there general!"))

    # Short ASCII and UTF-16 string comparison.
    t16s_test_equals_ascii(sv("hello"), utf16_string_from_str("๐Ÿ˜€"))

    # Short ASCII and UTF-16 string of same code unit length comparison.
    t16s_test_equals_ascii(sv("ab"), utf16_string_from_str("๐Ÿ˜€"))

    # Long ASCII and UTF-16 string comparison.
    t16s_test_equals_ascii(sv("hello there general!"), utf16_string_from_str("๐Ÿ˜€"))

    # Long ASCII and UTF-16 string of same code unit length comparison.
    t16s_test_equals_ascii(sv("ababababab"), utf16_string_from_str("๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€"))

    # Non-ASCII string comparison.
    let emoji = utf16_string_from_str("๐Ÿ˜€")
    assert(t16s_eq_str(&emoji, "๐Ÿ˜€"))

## `string1.equals_ignoring_ascii_case(string2)`.
func t16s_equals_ignoring_ascii_case(a: const Utf16String*, b: const Utf16String*) -> bool:
    return utf16_string_base_equals_ignoring_ascii_case_utf16_string_base(&a.utf16_string_base, &b.utf16_string_base)

## `string1.equals_ignoring_ascii_case(view)`.
func t16s_equals_ignoring_ascii_case_view(a: const Utf16String*, b: Utf16View) -> bool:
    return utf16_string_base_equals_ignoring_ascii_case_utf16_view(&a.utf16_string_base, &b)

## The `test` lambda of equals_ignoring_ascii_case.
func t16s_test_equals_ignoring_ascii_case(string1_value: Utf16String, inequal_value: Utf16String):
    let string1 = &string1_value
    let inequal_string = &inequal_value
    var builder = string_builder_new()
    var i: usize = 0
    var it = utf16_string_base_begin(&string1.utf16_string_base)
    while not utf16_code_point_iterator_done(&it):
        let code_point = utf16_code_point_iterator_deref(&it)
        string_builder_append_code_point(&builder, to_ascii_uppercase(code_point) if i % 2 == 0 else code_point)
        i += 1
        _ = utf16_code_point_iterator_inc(&it)

    let string2 = utf16_string_from_utf8_string_view(string_builder_string_view(&builder))

    assert(t16s_equals_ignoring_ascii_case(string1, string1))
    assert(t16s_equals_ignoring_ascii_case(string1, &string2))
    assert(t16s_equals_ignoring_ascii_case(&string2, string1))
    assert(t16s_equals_ignoring_ascii_case(&string2, &string2))

    if utf16_string_base_has_long_utf16_storage(&string1.utf16_string_base):
        assert(t16s_equals_ignoring_ascii_case_view(string1, t16s_view(string1)))
        assert(t16s_equals_ignoring_ascii_case_view(string1, t16s_view(&string2)))
        assert(t16s_equals_ignoring_ascii_case_view(&string2, t16s_view(string1)))
        assert(t16s_equals_ignoring_ascii_case_view(&string2, t16s_view(&string2)))

    assert(not t16s_equals_ignoring_ascii_case(string1, inequal_string))
    assert(not t16s_equals_ignoring_ascii_case(&string2, inequal_string))
    assert(not t16s_equals_ignoring_ascii_case(inequal_string, string1))
    assert(not t16s_equals_ignoring_ascii_case(inequal_string, &string2))

    if utf16_string_base_has_long_utf16_storage(&string1.utf16_string_base):
        assert(not t16s_equals_ignoring_ascii_case_view(string1, t16s_view(inequal_string)))
        assert(not t16s_equals_ignoring_ascii_case_view(&string2, t16s_view(inequal_string)))
        assert(not t16s_equals_ignoring_ascii_case_view(inequal_string, t16s_view(string1)))
        assert(not t16s_equals_ignoring_ascii_case_view(inequal_string, t16s_view(&string2)))

test "equals_ignoring_ascii_case":
    # Short (empty) ASCII string comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_new(), utf16_string_from_str("hello"))

    # Short ASCII string comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("hello"), utf16_string_from_str("there"))

    # Short and long ASCII string comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("hello"), utf16_string_from_str("hello there general!"))

    # Long ASCII string comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("hello there!"), utf16_string_from_str("hello there general!"))

    # UTF-16 string comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("๐Ÿ˜€"), utf16_string_from_str("hello ๐Ÿ˜€"))

    # Short ASCII and UTF-16 string comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("hello"), utf16_string_from_str("๐Ÿ˜€"))

    # Short ASCII and UTF-16 string of same code unit length comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("ab"), utf16_string_from_str("๐Ÿ˜€"))

    # Long ASCII and UTF-16 string comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("hello there general!"), utf16_string_from_str("๐Ÿ˜€"))

    # Long ASCII and UTF-16 string of same code unit length comparison.
    t16s_test_equals_ignoring_ascii_case(utf16_string_from_str("ababababab"), utf16_string_from_str("๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€๐Ÿ˜€"))

## The `test` lambda of iteration (the EXPECT_DEATH checks are not ported).
func t16s_test_iteration(string_value: Utf16String, code_points: const u32[]):
    let string = &string_value
    assert(utf16_string_base_length_in_code_points(&string.utf16_string_base) == code_points.length)

    var i: usize = 0
    var it = utf16_string_base_begin(&string.utf16_string_base)
    while not utf16_code_point_iterator_done(&it):
        assert(code_points.length != 0)
        assert(utf16_code_point_iterator_deref(&it) == code_points[i])
        i += 1
        _ = utf16_code_point_iterator_inc(&it)

test "iteration":
    let no_code_points: u32[1] = [0]
    t16s_test_iteration(utf16_string_new(), no_code_points[..<0])
    t16s_test_iteration(utf16_string_from_str("hello"), [0x68, 0x65, 0x6c, 0x6c, 0x6f])
    t16s_test_iteration(utf16_string_from_str("hello there general!"), [0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x21])
    t16s_test_iteration(utf16_string_from_str("๐Ÿ˜€"), [0x1f600])
    t16s_test_iteration(utf16_string_from_str("hello ๐Ÿ˜€ there!"), [0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x1f600, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x21])

## The `test` lambda of code_unit_at.
func t16s_test_code_unit_at(view: Utf16View, length_in_code_units: usize):
    let string = utf16_string_from_utf16(view)
    assert(utf16_string_base_length_in_code_units(&string.utf16_string_base) == length_in_code_units)

    for i in 0..<length_in_code_units:
        assert(utf16_string_base_code_unit_at(&string.utf16_string_base, i) == utf16_view_code_unit_at(&view, i))

test "code_unit_at":
    t16s_test_code_unit_at(utf16_view_new(), 0)
    t16s_test_code_unit_at(t16("hello"), 5)
    t16s_test_code_unit_at(t16("hello there general!"), 20)
    t16s_test_code_unit_at(t16("๐Ÿ˜€"), 2)
    t16s_test_code_unit_at(t16("hello ๐Ÿ˜€ there!"), 15)

## The `test` lambda of code_point_at.
func t16s_test_code_point_at(view: Utf16View, length_in_code_points: usize):
    let string = utf16_string_from_utf16(view)
    assert(utf16_string_base_length_in_code_points(&string.utf16_string_base) == length_in_code_points)

    for i in 0..<utf16_string_base_length_in_code_units(&string.utf16_string_base):
        assert(utf16_string_base_code_point_at(&string.utf16_string_base, i) == utf16_view_code_point_at(&view, i))

test "code_point_at":
    t16s_test_code_point_at(utf16_view_new(), 0)
    t16s_test_code_point_at(t16("hello"), 5)
    t16s_test_code_point_at(t16("hello there general!"), 20)
    t16s_test_code_point_at(t16("๐Ÿ˜€"), 1)
    t16s_test_code_point_at(t16("hello ๐Ÿ˜€ there!"), 14)

test "optional":
    # Optional<Utf16String> is a Luce optional here (the C++ uses the null sentinel, which does
    # not exist in the port: a zeroed Utf16String is the empty string).
    var string: Utf16String? = none
    assert(string == none)

    string = utf16_string_from_str("ascii")
    let ascii = string else trap("has_value")
    assert(t16s_eq_str(&ascii, "ascii"))

    var released = string else trap("release_value")
    string = none
    assert(string == none)
    assert(t16s_eq_str(&released, "ascii"))

    string = t16_lit("well ๐Ÿ˜€ hello")
    let emoji = string else trap("has_value")
    assert(t16s_eq(&emoji, t16("well ๐Ÿ˜€ hello")))

    released = string else trap("release_value")
    string = none
    assert(string == none)
    assert(t16s_eq(&released, t16("well ๐Ÿ˜€ hello")))