Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.1

0.6.1 / src / ak / tests_string_view.lucb

#==============================================================================================
#
#   tests_string_view - the StringView tests
#
#   DESCRIPTION:
#       Port of Tests/AK/TestStringView.cpp. conforms_to_iterator_protocol (a static_assert on
#       std::random_access_iterator) has no luce-base counterpart; constexpr_stuff runs its
#       static_asserts at run time, with `is_one_of` spelled as the comparisons it folds.
#
#==============================================================================================

## Whether a vector of views holds exactly the `expected` texts, in order.
func string_view_vector_equals(views: const Vector[StringView]*, expected: const str[]) -> bool:
    if test_vector_size(views) != expected.length:
        return false
    for i in 0..<expected.length:
        let view = test_vector_at(views, i)
        if not string_view_equals(&view, expected[i]):
            return false
    return true

test "construct_empty":
    let empty = StringView()
    assert(string_view_is_empty(&empty))
    assert(string_view_eq_string_view(&empty, sv("")))
    assert(string_view_length(&empty) == 0)

test "view_literal":
    let truth = "cats rule dogs drool"
    let view = literalsv_u8(truth.bytes.data, truth.length)
    assert(string_view_characters_without_null_termination(&view) == truth.bytes.data)
    assert(string_view_eq_string_view(&view, view))
    assert(string_view_eq_u8_const(&view, truth.bytes.data))

test "optional_string_view":
    var missing: StringView? = none
    assert(missing == none)

    let empty: StringView? = sv("")
    let empty_value = empty else trap("empty has a value")
    assert(string_view_is_empty(&empty_value))
    assert(string_view_equals(&empty_value, ""))

    var value: StringView? = sv("foo")
    let foo = value else trap("value has a value")
    assert(string_view_equals(&foo, "foo"))

    value = none
    assert(value == none)
    missing = sv("x")
    assert(missing != none)

test "compare_views":
    let foo1 = byte_string_from_str("foo")
    let foo2 = byte_string_from_str("foo")
    let view1 = byte_string_view(&foo1)
    let view2 = byte_string_view(&foo2)

    assert(string_view_eq_string_view(&view1, view2))
    assert(string_view_eq_byte_string(&view1, foo1))
    assert(string_view_eq_byte_string(&view1, foo2))
    assert(string_view_eq_u8_const(&view1, "foo".bytes.data))

    let empty = byte_string_from_str("")
    let empty_view = string_view_substring_view_usize(&view1, 0, 0)
    let default_view = StringView()
    let empty_string_view = byte_string_view(&empty)
    assert(string_view_equals(&empty_string_view, ""))
    assert(string_view_equals(&empty_view, ""))
    assert(string_view_equals(&default_view, ""))

test "string_view_literal_operator":
    let literal_view = sv("foo")
    let test_string = byte_string_from_str("foo")

    assert(string_view_length(&literal_view) == byte_string_length(&test_string))
    assert(string_view_eq_byte_string(&literal_view, test_string))

test "starts_with":
    let test_string = byte_string_from_str("ABCDEF")
    let test_string_view = byte_string_view(&test_string)
    assert(string_view_starts_with_u8(&test_string_view, 'A'))
    assert(not string_view_starts_with_u8(&test_string_view, 'B'))
    assert(string_view_starts_with_string_view(&test_string_view, sv("AB")))
    assert(string_view_starts_with_string_view(&test_string_view, sv("ABCDEF")))
    assert(not string_view_starts_with_string_view(&test_string_view, sv("DEF")))
    assert(string_view_starts_with_string_view(&test_string_view, sv("abc"), CaseSensitivity.case_insensitive))
    assert(not string_view_starts_with_string_view(&test_string_view, sv("abc"), CaseSensitivity.case_sensitive))

test "ends_with":
    let test_string = byte_string_from_str("ABCDEF")
    let test_string_view = byte_string_view(&test_string)
    assert(string_view_ends_with_string_view(&test_string_view, sv("DEF")))
    assert(string_view_ends_with_u8(&test_string_view, 'F'))
    assert(not string_view_ends_with_u8(&test_string_view, 'E'))
    assert(string_view_ends_with_string_view(&test_string_view, sv("ABCDEF")))
    assert(not string_view_ends_with_string_view(&test_string_view, sv("ABCDE")))
    assert(not string_view_ends_with_string_view(&test_string_view, sv("ABCDEFG")))
    assert(string_view_ends_with_string_view(&test_string_view, sv("def"), CaseSensitivity.case_insensitive))
    assert(not string_view_ends_with_string_view(&test_string_view, sv("def"), CaseSensitivity.case_sensitive))

test "lines":
    var test_string = byte_string_from_str("a\rb\nc\r\nd")
    var test_string_view = byte_string_view(&test_string)
    var test_string_vector = string_view_lines(&test_string_view)
    assert(test_vector_size(&test_string_vector) == 4)
    assert(string_view_vector_equals(&test_string_vector, ["a", "b", "c", "d"]))

    test_string = byte_string_from_str("```\nHello there\r\nHello there\n```")
    test_string_view = byte_string_view(&test_string)
    test_string_vector = string_view_lines(&test_string_view)
    assert(test_vector_size(&test_string_vector) == 4)
    assert(string_view_vector_equals(&test_string_vector, ["```", "Hello there", "Hello there", "```"]))

    test_string = byte_string_from_str("\n\n\n")
    test_string_view = byte_string_view(&test_string)
    test_string_vector = string_view_lines(&test_string_view)
    assert(test_vector_size(&test_string_vector) == 3)
    for i in 0..<3:
        let line = test_vector_at(&test_string_vector, (usize)i)
        assert(string_view_is_empty(&line) == true)

## `"text"sv.count_lines(consider_carriage_return)`.
func string_view_count_lines_of(text: str, consider_carriage_return: StringViewConsiderCarriageReturn = StringViewConsiderCarriageReturn.yes) -> usize:
    let view = sv(text)
    return string_view_count_lines(&view, consider_carriage_return)

test "count_lines":
    assert(string_view_count_lines_of("") == 1)
    assert(string_view_count_lines_of("foo") == 1)

    assert(string_view_count_lines_of("foo\nbar") == 2)
    assert(string_view_count_lines_of("foo\rbar") == 2)
    assert(string_view_count_lines_of("foo\rbar", StringViewConsiderCarriageReturn.no) == 1)
    assert(string_view_count_lines_of("foo\r\nbar") == 2)
    assert(string_view_count_lines_of("foo\r\nbar", StringViewConsiderCarriageReturn.no) == 2)

    assert(string_view_count_lines_of("foo\nbar\nbax") == 3)
    assert(string_view_count_lines_of("foo\rbar\rbaz") == 3)
    assert(string_view_count_lines_of("foo\rbar\rbaz", StringViewConsiderCarriageReturn.no) == 1)
    assert(string_view_count_lines_of("foo\r\nbar\r\nbaz") == 3)
    assert(string_view_count_lines_of("foo\r\nbar\r\nbaz", StringViewConsiderCarriageReturn.no) == 3)

test "find":
    let test_string_view = sv("aabbcc_xy_ccbbaa")
    assert(string_view_find_u8(&test_string_view, 'b') == 2)
    assert(string_view_find_u8(&test_string_view, '_') == 6)
    assert(string_view_find_u8(&test_string_view, 'n') == none)

test "find_last":
    var test_string_view = sv("aabbcc_xy_ccbbaa")
    assert(string_view_find_last_u8(&test_string_view, 'b') == 13)
    assert(string_view_find_last_u8(&test_string_view, '_') == 9)
    assert(string_view_find_last_u8(&test_string_view, '3') == none)

    test_string_view = sv("/")
    assert(string_view_find_last_u8(&test_string_view, '/') == 0)

test "find_any_of":
    var test_string_view = sv("aabbcc_xy_ccbbaa")
    assert(string_view_find_any_of(&test_string_view, sv("bc"), SearchDirection.forward) == 2)
    assert(string_view_find_any_of(&test_string_view, sv("yx"), SearchDirection.forward) == 7)
    assert(string_view_find_any_of(&test_string_view, sv("defg"), SearchDirection.forward) == none)
    assert(string_view_find_any_of(&test_string_view, sv("bc"), SearchDirection.backward) == 13)
    assert(string_view_find_any_of(&test_string_view, sv("yx"), SearchDirection.backward) == 8)
    assert(string_view_find_any_of(&test_string_view, sv("fghi"), SearchDirection.backward) == none)

    test_string_view = sv("/")
    assert(string_view_find_any_of(&test_string_view, sv("/"), SearchDirection.forward) == 0)
    assert(string_view_find_any_of(&test_string_view, sv("/"), SearchDirection.backward) == 0)

## The `[](char ch) { return ch == 'x' || ch == '_'; }` predicate of split_view.
struct StringViewSplitViewTestPredicate: CharPredicate:
    var unused: u8

    func matches(ch: u8) -> bool:
        return ch == 'x' or ch == '_'

test "split_view":
    var test_string_view = sv("axxbxcxd")
    var parts = string_view_split_view_u8(&test_string_view, 'x')
    assert(string_view_vector_equals(&parts, ["a", "b", "c", "d"]))
    parts = string_view_split_view_u8(&test_string_view, 'x', SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a", "", "b", "c", "d"]))
    parts = string_view_split_view_string_view(&test_string_view, sv("x"))
    assert(string_view_vector_equals(&parts, ["a", "b", "c", "d"]))
    parts = string_view_split_view_string_view(&test_string_view, sv("x"), SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a", "", "b", "c", "d"]))

    test_string_view = sv("axxbx")
    parts = string_view_split_view_u8(&test_string_view, 'x')
    assert(string_view_vector_equals(&parts, ["a", "b"]))
    parts = string_view_split_view_u8(&test_string_view, 'x', SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a", "", "b", ""]))
    parts = string_view_split_view_string_view(&test_string_view, sv("x"))
    assert(string_view_vector_equals(&parts, ["a", "b"]))
    parts = string_view_split_view_string_view(&test_string_view, sv("x"), SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a", "", "b", ""]))

    test_string_view = sv("axxbcxxdxx")
    parts = string_view_split_view_string_view(&test_string_view, sv("xx"))
    assert(string_view_vector_equals(&parts, ["a", "bc", "d"]))
    parts = string_view_split_view_string_view(&test_string_view, sv("xx"), SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a", "bc", "d", ""]))

    test_string_view = sv("ax_b_cxd")
    let predicate = StringViewSplitViewTestPredicate(unused = 0)
    parts = string_view_split_view_if(&test_string_view, &predicate)
    assert(string_view_vector_equals(&parts, ["a", "b", "c", "d"]))
    parts = string_view_split_view_if(&test_string_view, &predicate, SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a", "", "b", "c", "d"]))

    test_string_view = sv("a,,,b")
    parts = string_view_split_view_string_view(&test_string_view, sv(","), SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a", "", "", "b"]))
    parts = string_view_split_view_string_view(&test_string_view, sv(","), SplitBehavior.keep_trailing_separator)
    assert(string_view_vector_equals(&parts, ["a,", "b"]))
    parts = string_view_split_view_string_view(&test_string_view, sv(","), SplitBehavior.keep_trailing_separator | SplitBehavior.keep_empty)
    assert(string_view_vector_equals(&parts, ["a,", ",", ",", "b"]))

test "constexpr_stuff":
    # Can initialize from ""sv.
    let test_constexpr = sv("foo")
    assert(string_view_length(&test_constexpr) == 3)
    assert(not string_view_is_empty(&test_constexpr))
    assert(string_view_equals(&test_constexpr, "foo") or string_view_equals(&test_constexpr, "bar") or string_view_equals(&test_constexpr, "baz"))
    assert(string_view_ne(&test_constexpr, sv("fob")))
    assert(not string_view_eq_u8_const(&test_constexpr, "fob".bytes.data))
    let tail = string_view_substring_view(&test_constexpr, 1)
    assert(string_view_equals(&tail, "oo"))

test "case_insensitive_hash":
    let string1 = sv("abcdef")
    let string2 = sv("ABCDEF")
    let string3 = sv("aBcDeF")
    let string4 = sv("foo")

    assert(case_insensitive_ascii_string_view_traits_hash(string1) == case_insensitive_ascii_string_view_traits_hash(string2))
    assert(case_insensitive_ascii_string_view_traits_hash(string1) == case_insensitive_ascii_string_view_traits_hash(string3))
    assert(case_insensitive_ascii_string_view_traits_hash(string1) != case_insensitive_ascii_string_view_traits_hash(string4))

test "case_insensitive_traits_key_a_hash_map":
    # Not in the donor's tests: CaseInsensitiveASCIIStringViewTraits as the traits of a HashMap, as
    # LibWeb's generated keyword and property tables use it.
    var map: HashMap[StringView, i32, CaseInsensitiveAsciiStringViewTraits]
    assert(hash_map_set(&map, sv("background-color"), 1) == HashSetResult.inserted_new_entry)
    assert(hash_map_set(&map, sv("Color"), 2) == HashSetResult.inserted_new_entry)
    assert(hash_map_set(&map, sv("BACKGROUND-COLOR"), 3) == HashSetResult.replaced_existing_entry)
    assert(hash_map_size(&map) == 2)

    let background = hash_map_get_k(&map, sv("Background-Color")) else trap("missing background-color")
    assert(*background == 3)
    let color = hash_map_get_k(&map, sv("cOLOR")) else trap("missing color")
    assert(*color == 2)
    assert(not hash_map_contains_k(&map, sv("colour")))