dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / 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)))