Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / tests_numbers_and_dates.lucb

#==============================================================================================
#
#   tests_numbers_and_dates - tests of HTML::Numbers and HTML::Dates (region r22)
#
#   DESCRIPTION:
#       Ports Ladybird's Tests/LibWeb/TestNumbers.cpp (parse_integer, parse_non_negative_integer,
#       is_valid_floating_point_number) and Tests/LibWeb/TestMicrosyntax.cpp
#       (week_number_of_the_last_day), then pins every other function of Numbers.cpp and
#       Dates.cpp to values printed by a local oracle that compiles the donor's Numbers.cpp and
#       Dates.cpp against the reference build's AK and LibJS: integer edge cases (signs, ranges,
#       whitespace, a non-ASCII digit), floating-point values as bits (fractions, exponents,
#       overflow, denormals, negative zero), the valid week / month / date / time / local date
#       and time strings, normalized local date and time strings, and the month, week, date and
#       local date and time parsers. Inputs on which the donor fails a VERIFY (a leading space in
#       a date string) are left out: the port traps there too.
#
#==============================================================================================

# mark: TestNumbers.cpp =========================================================================

## Whether `parse_integer(input)` is `expected`.
func html_test_parse_integer_is(input: str, expected: i32?) -> bool:
    return html_parse_integer(ak.sv(input)) == expected

## Whether `parse_non_negative_integer(input)` is `expected`.
func html_test_parse_non_negative_integer_is(input: str, expected: u32?) -> bool:
    return html_parse_non_negative_integer(ak.sv(input)) == expected

test "TestNumbers: parse_integer":
    assert(html_test_parse_integer_is("", none))
    assert(html_test_parse_integer_is("123", 123))
    assert(html_test_parse_integer_is(" 456", 456))
    assert(html_test_parse_integer_is("789 ", 789))
    assert(html_test_parse_integer_is("   22   ", 22))
    assert(html_test_parse_integer_is(" \n\t31\t\t\n\n", 31))
    assert(html_test_parse_integer_is("765foo", 765))
    assert(html_test_parse_integer_is("3;", 3))
    assert(html_test_parse_integer_is("foo765", none))
    assert(html_test_parse_integer_is("1", 1))
    assert(html_test_parse_integer_is("+2", 2))
    assert(html_test_parse_integer_is("-3", -3))

test "TestNumbers: parse_non_negative_integer and is_valid_floating_point_number":
    assert(html_test_parse_non_negative_integer_is("", none))
    assert(html_test_parse_non_negative_integer_is("123", 123))
    assert(html_test_parse_non_negative_integer_is(" 456", 456))
    assert(html_test_parse_non_negative_integer_is("789 ", 789))
    assert(html_test_parse_non_negative_integer_is("   22   ", 22))
    assert(html_test_parse_non_negative_integer_is(" \n\t31\t\t\n\n", 31))
    assert(html_test_parse_non_negative_integer_is("765foo", 765))
    assert(html_test_parse_non_negative_integer_is("3;", 3))
    assert(html_test_parse_non_negative_integer_is("foo765", none))
    assert(html_test_parse_non_negative_integer_is("1", 1))
    assert(html_test_parse_non_negative_integer_is("+2", 2))
    assert(html_test_parse_non_negative_integer_is("-3", none))

    assert(html_is_valid_floating_point_number_string_view(ak.sv("11")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("11.12")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("-11111")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("-11111.123")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("1e2")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("1E2")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("1e+2")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("1d+2")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("foobar")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv(".1")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("1.")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("-0")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("Infinity")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("-Infinity")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("NaN")))
    assert(html_is_valid_floating_point_number_string_view(ak.sv("9007199254740993")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("1e")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("+1")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("+")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("-")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("\t1")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("\n1")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("\u{c}1")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("\r1")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv(" 1")))
    assert(not html_is_valid_floating_point_number_string_view(ak.sv("1trailing junk")))

# mark: TestMicrosyntax.cpp =====================================================================

test "TestMicrosyntax: week_number_of_the_last_day":
    assert(html_week_number_of_the_last_day(1998) == 53)
    assert(html_week_number_of_the_last_day(1999) == 52)
    assert(html_week_number_of_the_last_day(2000) == 52)
    assert(html_week_number_of_the_last_day(2001) == 52)
    assert(html_week_number_of_the_last_day(2002) == 52)
    assert(html_week_number_of_the_last_day(2003) == 52)
    assert(html_week_number_of_the_last_day(2004) == 53)
    assert(html_week_number_of_the_last_day(2005) == 52)
    assert(html_week_number_of_the_last_day(2006) == 52)
    assert(html_week_number_of_the_last_day(2007) == 52)
    assert(html_week_number_of_the_last_day(2008) == 52)
    assert(html_week_number_of_the_last_day(2009) == 53)

# mark: Oracle values: Numbers ==================================================================

## The rules for parsing integers and non-negative integers: input, parse_integer, parse_non_negative_integer.
struct HtmlTestIntegerCase:
    let input: str
    let integer: i64?
    let non_negative: i64?

let html_test_integer_cases: HtmlTestIntegerCase[30] = [
    HtmlTestIntegerCase(input = "", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "123", integer = 123, non_negative = 123),
    HtmlTestIntegerCase(input = " 456", integer = 456, non_negative = 456),
    HtmlTestIntegerCase(input = "789 ", integer = 789, non_negative = 789),
    HtmlTestIntegerCase(input = "   22   ", integer = 22, non_negative = 22),
    HtmlTestIntegerCase(input = " \n\t31\t\t\n\n", integer = 31, non_negative = 31),
    HtmlTestIntegerCase(input = "765foo", integer = 765, non_negative = 765),
    HtmlTestIntegerCase(input = "3;", integer = 3, non_negative = 3),
    HtmlTestIntegerCase(input = "foo765", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "1", integer = 1, non_negative = 1),
    HtmlTestIntegerCase(input = "+2", integer = 2, non_negative = 2),
    HtmlTestIntegerCase(input = "-3", integer = -3, non_negative = none),
    HtmlTestIntegerCase(input = "-0", integer = 0, non_negative = 0),
    HtmlTestIntegerCase(input = "-01", integer = -1, non_negative = 4294967295),
    HtmlTestIntegerCase(input = "2147483647", integer = 2147483647, non_negative = 2147483647),
    HtmlTestIntegerCase(input = "2147483648", integer = none, non_negative = 2147483648),
    HtmlTestIntegerCase(input = "-2147483648", integer = -2147483648, non_negative = none),
    HtmlTestIntegerCase(input = "-2147483649", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "4294967295", integer = none, non_negative = 4294967295),
    HtmlTestIntegerCase(input = "4294967296", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "99999999999999999999", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "\u{c}12", integer = 12, non_negative = 12),
    HtmlTestIntegerCase(input = "\n7", integer = 7, non_negative = 7),
    HtmlTestIntegerCase(input = "\u{b}8", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "+", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "-", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = "00012", integer = 12, non_negative = 12),
    HtmlTestIntegerCase(input = "+-1", integer = none, non_negative = none),
    HtmlTestIntegerCase(input = " -0x10", integer = 0, non_negative = 0),
    HtmlTestIntegerCase(input = "\u{ff11}\u{ff12}", integer = none, non_negative = none),
]

## parse_floating_point_number: input and the bits of the result.
struct HtmlTestFloatCase:
    let input: str
    let bits: u64?

let html_test_float_cases: HtmlTestFloatCase[43] = [
    HtmlTestFloatCase(input = "", bits = none),
    HtmlTestFloatCase(input = "1", bits = 0x3ff0000000000000),
    HtmlTestFloatCase(input = "-1", bits = 0xbff0000000000000),
    HtmlTestFloatCase(input = "+1", bits = 0x3ff0000000000000),
    HtmlTestFloatCase(input = "1.5", bits = 0x3ff8000000000000),
    HtmlTestFloatCase(input = "-1.5", bits = 0xbff8000000000000),
    HtmlTestFloatCase(input = ".5", bits = 0x3fe0000000000000),
    HtmlTestFloatCase(input = "-.5", bits = 0xbfe0000000000000),
    HtmlTestFloatCase(input = "+.5", bits = 0x3fe0000000000000),
    HtmlTestFloatCase(input = "1.", bits = 0x3ff0000000000000),
    HtmlTestFloatCase(input = "1.e3", bits = 0x408f400000000000),
    HtmlTestFloatCase(input = "1e3", bits = 0x408f400000000000),
    HtmlTestFloatCase(input = "1E3", bits = 0x408f400000000000),
    HtmlTestFloatCase(input = "1e-3", bits = 0x3f50624dd2f1a9fc),
    HtmlTestFloatCase(input = "1e+3", bits = 0x408f400000000000),
    HtmlTestFloatCase(input = "1e", bits = 0x3ff0000000000000),
    HtmlTestFloatCase(input = "1e-", bits = 0x3ff0000000000000),
    HtmlTestFloatCase(input = "1e+", bits = 0x3ff0000000000000),
    HtmlTestFloatCase(input = "1ex", bits = 0x3ff0000000000000),
    HtmlTestFloatCase(input = "1.25e2x", bits = 0x405f400000000000),
    HtmlTestFloatCase(input = "  \t3.25", bits = 0x400a000000000000),
    HtmlTestFloatCase(input = "abc", bits = none),
    HtmlTestFloatCase(input = ".", bits = none),
    HtmlTestFloatCase(input = "-", bits = none),
    HtmlTestFloatCase(input = "+", bits = none),
    HtmlTestFloatCase(input = "1.0000000000000002", bits = 0x3ff0000000000001),
    HtmlTestFloatCase(input = "123456789012345678901234567890", bits = 0x45f8ee90ff6c373e),
    HtmlTestFloatCase(input = "1e308", bits = 0x7fe1ccf385ebc8a0),
    HtmlTestFloatCase(input = "1e309", bits = none),
    HtmlTestFloatCase(input = "-1e309", bits = none),
    HtmlTestFloatCase(input = "-0", bits = 0x0000000000000000),
    HtmlTestFloatCase(input = "-0.0", bits = 0x0000000000000000),
    HtmlTestFloatCase(input = "0.1e-320", bits = 0x00000000000000ca),
    HtmlTestFloatCase(input = "1e-400", bits = 0x0000000000000000),
    HtmlTestFloatCase(input = "9007199254740993", bits = 0x4340000000000000),
    HtmlTestFloatCase(input = "0.30000000000000004", bits = 0x3fd3333333333334),
    HtmlTestFloatCase(input = "1.5.5", bits = 0x3ff8000000000000),
    HtmlTestFloatCase(input = "2e1.5", bits = 0x4034000000000000),
    HtmlTestFloatCase(input = "7 ", bits = 0x401c000000000000),
    HtmlTestFloatCase(input = "-.e1", bits = none),
    HtmlTestFloatCase(input = "5e0001", bits = 0x4049000000000000),
    HtmlTestFloatCase(input = "1.123456789", bits = 0x3ff1f9add3739636),
    HtmlTestFloatCase(input = "-1e-7", bits = 0xbe7ad7f29abcaf48),
]

## A validity check: input and whether it is valid.
struct HtmlTestValidCase:
    let input: str
    let valid: bool

let html_test_valid_float_cases: HtmlTestValidCase[31] = [
    HtmlTestValidCase(input = "11", valid = true),
    HtmlTestValidCase(input = "11.12", valid = true),
    HtmlTestValidCase(input = "-11111", valid = true),
    HtmlTestValidCase(input = "-11111.123", valid = true),
    HtmlTestValidCase(input = "1e2", valid = true),
    HtmlTestValidCase(input = "1E2", valid = true),
    HtmlTestValidCase(input = "1e+2", valid = true),
    HtmlTestValidCase(input = "1d+2", valid = false),
    HtmlTestValidCase(input = "foobar", valid = false),
    HtmlTestValidCase(input = ".1", valid = true),
    HtmlTestValidCase(input = "1.", valid = false),
    HtmlTestValidCase(input = "-0", valid = true),
    HtmlTestValidCase(input = "Infinity", valid = false),
    HtmlTestValidCase(input = "-Infinity", valid = false),
    HtmlTestValidCase(input = "NaN", valid = false),
    HtmlTestValidCase(input = "9007199254740993", valid = true),
    HtmlTestValidCase(input = "1e", valid = false),
    HtmlTestValidCase(input = "+1", valid = false),
    HtmlTestValidCase(input = "+", valid = false),
    HtmlTestValidCase(input = "-", valid = false),
    HtmlTestValidCase(input = "\t1", valid = false),
    HtmlTestValidCase(input = "\n1", valid = false),
    HtmlTestValidCase(input = "\u{c}1", valid = false),
    HtmlTestValidCase(input = "\n1", valid = false),
    HtmlTestValidCase(input = " 1", valid = false),
    HtmlTestValidCase(input = "1trailing junk", valid = false),
    HtmlTestValidCase(input = "-.5", valid = true),
    HtmlTestValidCase(input = "1e-5", valid = true),
    HtmlTestValidCase(input = "1E+05", valid = true),
    HtmlTestValidCase(input = "0.0e0", valid = true),
    HtmlTestValidCase(input = "", valid = false),
]

test "parse_integer and parse_non_negative_integer: signs, ranges, whitespace and non-ASCII digits":
    for case in html_test_integer_cases:
        let integer = html_parse_integer(ak.sv(case.input))
        if let expected = case.integer:
            assert(integer == (i32)expected, case.input)
        else:
            assert(integer == none, case.input)
        let non_negative = html_parse_non_negative_integer(ak.sv(case.input))
        if let expected = case.non_negative:
            assert(non_negative == (u32)expected, case.input)
        else:
            assert(non_negative == none, case.input)

test "parse_floating_point_number: fractions, exponents, overflow, denormals and negative zero":
    for case in html_test_float_cases:
        let value = html_parse_floating_point_number_string_view(ak.sv(case.input))
        if let expected = case.bits:
            let parsed = value else trap(case.input)
            assert(parsed.bits() == expected, case.input)
            # The UTF-16 overload reads the same ASCII text.
            let from_utf16 = html_parse_floating_point_number_utf16_string(ak.utf16_string_from_str(case.input)) else trap(case.input)
            assert(from_utf16.bits() == expected, case.input)
        else:
            assert(value == none, case.input)

test "parse_floating_point_number and is_valid_floating_point_number of UTF-16 storage fail":
    let text = ak.utf16_string_from_str("1.5\u{e9}")
    assert(html_parse_floating_point_number_utf16_string(text) == none)
    assert(not html_is_valid_floating_point_number_utf16_string(text))

test "is_valid_floating_point_number":
    for case in html_test_valid_float_cases:
        assert(html_is_valid_floating_point_number_string_view(ak.sv(case.input)) == case.valid, case.input)
        assert(html_is_valid_floating_point_number_utf16_string(ak.utf16_string_from_str(case.input)) == case.valid, case.input)

test "convert_non_negative_integer_to_string: IndexSizeError below zero":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let zero = html_convert_non_negative_integer_to_string(realm, 0) else trap("0 is non-negative")
    assert(ak.string_eq_string_view(&zero, ak.sv("0")))
    let large = html_convert_non_negative_integer_to_string(realm, 2147483647) else trap("i32 max is non-negative")
    assert(ak.string_eq_string_view(&large, ak.sv("2147483647")))
    var failed = false
    _ = html_convert_non_negative_integer_to_string(realm, -1) catch:
        failed = true
        recover ak.string_new()
    assert(failed)
    let exception = idl_take_pending_exception()
    match exception:
        .idl_dom_exception(dom_exception):
            let name = idl_dom_exception_name(dom_exception)
            assert(ak.fly_string_eq_string_view(&name, ak.sv("IndexSizeError")))
        _: trap("expected a DOMException")

# mark: Oracle values: Dates ====================================================================

let html_test_last_week_cases: (u64, u32)[15] = [
    (1, 52),
    (4, 53),
    (100, 52),
    (400, 52),
    (1970, 53),
    (1997, 52),
    (2003, 52),
    (2004, 53),
    (2015, 53),
    (2020, 53),
    (2026, 53),
    (2032, 53),
    (9999, 52),
    (10000, 52),
    (275760, 52),
]

let html_test_valid_week_cases: HtmlTestValidCase[16] = [
    HtmlTestValidCase(input = "2020-W01", valid = true),
    HtmlTestValidCase(input = "2020-W53", valid = true),
    HtmlTestValidCase(input = "2021-W53", valid = false),
    HtmlTestValidCase(input = "2004-W53", valid = true),
    HtmlTestValidCase(input = "0000-W01", valid = false),
    HtmlTestValidCase(input = "999-W01", valid = false),
    HtmlTestValidCase(input = "12345-W10", valid = true),
    HtmlTestValidCase(input = "2020-W00", valid = false),
    HtmlTestValidCase(input = "2020-w01", valid = false),
    HtmlTestValidCase(input = "2020-W1", valid = false),
    HtmlTestValidCase(input = "2020-W001", valid = false),
    HtmlTestValidCase(input = "2020W01", valid = false),
    HtmlTestValidCase(input = " 2020-W01", valid = true),
    HtmlTestValidCase(input = "2020-W5a", valid = false),
    HtmlTestValidCase(input = "1998-W53", valid = true),
    HtmlTestValidCase(input = "1999-W53", valid = false),
]

let html_test_valid_month_cases: HtmlTestValidCase[15] = [
    HtmlTestValidCase(input = "2020-01", valid = true),
    HtmlTestValidCase(input = "2020-12", valid = true),
    HtmlTestValidCase(input = "2020-13", valid = false),
    HtmlTestValidCase(input = "2020-00", valid = false),
    HtmlTestValidCase(input = "0000-01", valid = false),
    HtmlTestValidCase(input = "999-01", valid = false),
    HtmlTestValidCase(input = "12345-06", valid = true),
    HtmlTestValidCase(input = "2020-1", valid = false),
    HtmlTestValidCase(input = "2020-001", valid = false),
    HtmlTestValidCase(input = "2020-0a", valid = false),
    HtmlTestValidCase(input = " 2020-01", valid = true),
    HtmlTestValidCase(input = "2020/01", valid = false),
    HtmlTestValidCase(input = "2020-01-01", valid = false),
    HtmlTestValidCase(input = "+2020-01", valid = false),
    HtmlTestValidCase(input = "0001-01", valid = true),
]

let html_test_valid_date_cases: HtmlTestValidCase[15] = [
    HtmlTestValidCase(input = "2020-01-31", valid = true),
    HtmlTestValidCase(input = "2020-02-29", valid = true),
    HtmlTestValidCase(input = "2019-02-29", valid = false),
    HtmlTestValidCase(input = "2000-02-29", valid = true),
    HtmlTestValidCase(input = "1900-02-29", valid = false),
    HtmlTestValidCase(input = "2020-04-31", valid = false),
    HtmlTestValidCase(input = "2020-04-30", valid = true),
    HtmlTestValidCase(input = "2020-13-01", valid = false),
    HtmlTestValidCase(input = "2020-01-00", valid = false),
    HtmlTestValidCase(input = "2020-1-01", valid = false),
    HtmlTestValidCase(input = "2020-01-1", valid = false),
    HtmlTestValidCase(input = "0000-01-01", valid = false),
    HtmlTestValidCase(input = "12345-12-31", valid = true),
    HtmlTestValidCase(input = "2020-01-01-", valid = false),
    HtmlTestValidCase(input = "2020-01", valid = false),
]

let html_test_valid_time_cases: HtmlTestValidCase[20] = [
    HtmlTestValidCase(input = "00:00", valid = true),
    HtmlTestValidCase(input = "23:59", valid = true),
    HtmlTestValidCase(input = "24:00", valid = false),
    HtmlTestValidCase(input = "12:60", valid = false),
    HtmlTestValidCase(input = "12:00:00", valid = true),
    HtmlTestValidCase(input = "12:00:59", valid = true),
    HtmlTestValidCase(input = "12:00:60", valid = false),
    HtmlTestValidCase(input = "12:00:00.1", valid = true),
    HtmlTestValidCase(input = "12:00:00.12", valid = true),
    HtmlTestValidCase(input = "12:00:00.123", valid = true),
    HtmlTestValidCase(input = "12:00:00.1234", valid = false),
    HtmlTestValidCase(input = "12:00:00.", valid = false),
    HtmlTestValidCase(input = "12:00:00.1.2", valid = false),
    HtmlTestValidCase(input = "1:00", valid = false),
    HtmlTestValidCase(input = "12:0", valid = false),
    HtmlTestValidCase(input = "12:00:0", valid = false),
    HtmlTestValidCase(input = "12:00:00a", valid = false),
    HtmlTestValidCase(input = "ab:cd", valid = false),
    HtmlTestValidCase(input = "12:00:00.a", valid = false),
    HtmlTestValidCase(input = "12:30:45.5", valid = true),
]

let html_test_valid_local_date_and_time_cases: HtmlTestValidCase[10] = [
    HtmlTestValidCase(input = "2020-01-01T12:00", valid = true),
    HtmlTestValidCase(input = "2020-01-01 12:00", valid = true),
    HtmlTestValidCase(input = "2020-01-01T12:00:00.123", valid = true),
    HtmlTestValidCase(input = "2020-01-01t12:00", valid = false),
    HtmlTestValidCase(input = "2020-01-01T24:00", valid = false),
    HtmlTestValidCase(input = "2020-02-30T00:00", valid = false),
    HtmlTestValidCase(input = "2020-01-01", valid = false),
    HtmlTestValidCase(input = "2020-01-01T", valid = false),
    HtmlTestValidCase(input = "2020-01-01TT12:00", valid = false),
    HtmlTestValidCase(input = "2020-01-01  12:00", valid = false),
]

let html_test_normalize_cases: (str, str)[10] = [
    ("2020-01-01T12:00", "2020-01-01T12:00"),
    ("2020-01-01 12:00", "2020-01-01T12:00"),
    ("2020-01-01T12:00:00", "2020-01-01T12:00"),
    ("2020-01-01T12:00:30", "2020-01-01T12:00:30"),
    ("2020-01-01T12:00:00.000", "2020-01-01T12:00"),
    ("2020-01-01T12:00:00.100", "2020-01-01T12:00:00.1"),
    ("2020-01-01T12:00:00.120", "2020-01-01T12:00:00.12"),
    ("2020-01-01T12:00:30.000", "2020-01-01T12:00:30"),
    ("2020-01-01T12:00:00.123", "2020-01-01T12:00:00.123"),
    ("2020-01-01T12:00:00.5", "2020-01-01T12:00:00.5"),
]

## parse_a_month_string: input, year, month and the months since the epoch (year 0 = failure).
let html_test_month_string_cases: (str, u32, u32, i32)[12] = [
    ("2020-01", 2020, 1, 600),
    ("2020-12", 2020, 12, 611),
    ("2020-13", 0, 0, 0),
    ("0000-01", 0, 0, 0),
    ("999-01", 0, 0, 0),
    ("12345-06", 12345, 6, 124505),
    ("2020-1", 0, 0, 0),
    ("2020-01x", 0, 0, 0),
    ("99999999999-01", 0, 0, 0),
    ("2020-00", 0, 0, 0),
    ("4294967295-01", 4294967295, 1, -23652),
    ("4294967296-01", 0, 0, 0),
]

## parse_a_week_string: input, week-year and week (0 = failure).
let html_test_week_string_cases: (str, u32, u32)[9] = [
    ("2020-W01", 2020, 1),
    ("2020-W53", 2020, 53),
    ("2021-W53", 0, 0),
    ("2020-W00", 0, 0),
    ("2020-W1", 0, 0),
    ("2020-01", 0, 0),
    ("2020-W01x", 0, 0),
    ("0000-W01", 0, 0),
    ("2004-W53", 2004, 53),
]

## parse_a_date_string: input, year, month and day (0 = failure).
let html_test_date_string_cases: (str, u32, u32, u32)[8] = [
    ("2020-02-29", 2020, 2, 29),
    ("2019-02-29", 0, 0, 0),
    ("2020-04-31", 0, 0, 0),
    ("2020-13-01", 0, 0, 0),
    ("2020-01-00", 0, 0, 0),
    ("2020-01-01x", 0, 0, 0),
    ("0001-01-01", 1, 1, 1),
    ("2020-1-01", 0, 0, 0),
]

## parse_a_local_date_and_time_string: input, year, month, day, hour, minute and the bits of the
## seconds (year 0 = failure).
let html_test_local_date_and_time_cases: (str, u32, u32, u32, i32, i32, u32)[15] = [
    ("2020-01-01T12:00", 2020, 1, 1, 12, 0, 0x00000000),
    ("2020-01-01 12:00:30", 2020, 1, 1, 12, 0, 0x41f00000),
    ("2020-01-01T12:00:30.5", 2020, 1, 1, 12, 0, 0x41f40000),
    ("2020-01-01T12:75", 2020, 1, 1, 12, 75, 0x00000000),
    ("2020-01-01T24:00", 0, 0, 0, 0, 0, 0),
    ("2020-01-01X12:00", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:5", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:005", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:05.", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:05.1.2", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:60", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:59.999", 2020, 1, 1, 12, 0, 0x426ffefa),
    ("2020-01-01T12:00:5.5", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:a5", 0, 0, 0, 0, 0, 0),
    ("2020-01-01T12:00:", 0, 0, 0, 0, 0, 0),
]

test "week_number_of_the_last_day over the centuries":
    for case in html_test_last_week_cases:
        assert(html_week_number_of_the_last_day(case.0) == case.1)

## Runs a valid-string check over a table.
func html_test_check_valid(cases: const HtmlTestValidCase[], check: func(ak.Utf16View) -> bool):
    for case in cases:
        let text = ak.utf16_string_from_str(case.input)
        assert(check(ak.utf16_string_base_utf16_view(&text.utf16_string_base)) == case.valid, case.input)

test "valid week, month, date, time and local date and time strings":
    html_test_check_valid(html_test_valid_week_cases, html_is_valid_week_string)
    html_test_check_valid(html_test_valid_month_cases, html_is_valid_month_string)
    html_test_check_valid(html_test_valid_date_cases, html_is_valid_date_string)
    html_test_check_valid(html_test_valid_time_cases, html_is_valid_time_string)
    html_test_check_valid(html_test_valid_local_date_and_time_cases, html_is_valid_local_date_and_time_string)

test "normalize_local_date_and_time_string drops zero seconds and trailing zero digits":
    for case in html_test_normalize_cases:
        let normalized = html_normalize_local_date_and_time_string(ak.utf16_string_from_str(case.0))
        assert(ak.utf16_string_base_eq_string_view(&normalized.utf16_string_base, ak.sv(case.1)), case.0)

test "parse_a_month_string and number_of_months_since_unix_epoch":
    for case in html_test_month_string_cases:
        let parsed = html_parse_a_month_string(ak.sv(case.0))
        if case.1 == 0:
            assert(parsed == none, case.0)
        else:
            let year_and_month = parsed else trap(case.0)
            assert(year_and_month.year == case.1 and year_and_month.month == case.2, case.0)
            assert(html_number_of_months_since_unix_epoch(year_and_month) == case.3, case.0)

test "parse_a_week_string":
    for case in html_test_week_string_cases:
        let parsed = html_parse_a_week_string(ak.sv(case.0))
        if case.1 == 0:
            assert(parsed == none, case.0)
        else:
            let week = parsed else trap(case.0)
            assert(week.week_year == case.1 and week.week == case.2, case.0)

test "parse_a_date_string":
    for case in html_test_date_string_cases:
        let parsed = html_parse_a_date_string(ak.sv(case.0))
        if case.1 == 0:
            assert(parsed == none, case.0)
        else:
            let date = parsed else trap(case.0)
            assert(date.year == case.1 and date.month == case.2 and date.day == case.3, case.0)

test "parse_a_local_date_and_time_string, with the donor's minute check (minutes up to 99 parse)":
    for case in html_test_local_date_and_time_cases:
        let parsed = html_parse_a_local_date_and_time_string(ak.sv(case.0))
        if case.1 == 0:
            assert(parsed == none, case.0)
        else:
            let value = parsed else trap(case.0)
            assert(value.date.year == case.1 and value.date.month == case.2 and value.date.day == case.3, case.0)
            assert(value.time.hour == case.4 and value.time.minute == case.5, case.0)
            assert(value.time.second.bits() == case.6, case.0)

test "parse_time_string: a TypeError when the time does not parse":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let realm = web_test_create_realm(vm)
    let inputs: str[3] = ["", "12:00x", "1:00"]
    for input in inputs:
        var failed = false
        _ = html_parse_time_string(realm, ak.sv(input)) catch:
            failed = true
            recover (JsDate*)realm
        assert(failed, input)
        let exception = idl_take_pending_exception()
        match exception:
            .idl_simple_exception(simple):
                assert(simple.type_ == IdlSimpleExceptionType.type_error)
            _: trap("expected a TypeError")

test "make_time: the milliseconds of a time component":
    assert(js_make_time(12.0, 30.0, 15.0, 250.0) == 45015250.0)
    assert(js_make_time(1.9, -0.5, 0.0, 0.0) == 3600000.0)
    assert(math.is_nan(js_make_time(math.infinity, 0.0, 0.0, 0.0)))