imported>Erutuon: Module:Table → Module:TableTools

2019-03-04T21:32:33Z

New page

local p = require "Module:UnitTests"
local parse_IETF = require "Module:Sandbox/Erutuon".parse_IETF
local fun = require "Module:Fun"

local show = {
language = function (subtags, key)
if not subtags[key] then return nil end
return ("%s: <code>%s</code>"):format(key, subtags[key] or '')
end,
variant = function (subtags, key)
if not subtags[key] then return nil end
return ("%s: <code>%s</code>"):format(
key,
type(subtags[key]) == "table" and table.concat(subtags[key], ", ")
or subtags[key] or '')
end,
error = function (subtags, key)
if not subtags.error then
return nil
end

return ("error: %s at <code>%s</code>")
:format(subtags.error, subtags.invalid or "???")
end,
}

show.script = show.language
show.region = show.language
show.private_use = show.variant

local items = { "language", "script", "region", "variant", "private_use",
"error" } -- "invalid" is handled together with "error".

local mt = {}
mt.__index = table
local function show_parsed_subtags(parsed_subtags)
if not parsed_subtags then return 'nil' end

local result = setmetatable({}, mt)

for _, key in ipairs(items) do
result:insert(show[key](parsed_subtags, key))
end

return result:concat("; ")
end

function p:test_parse_IETF()
local examples = {
{ "ru", { language = "ru" } },
{ "ru-Latn", { language = "ru", script = "Latn" } },
{ "fr-CA", { language = "fr", region = "CA" } },
{ "ru-petr1708", { language = "ru", variant = "petr1708" } },
{ "zh-Latn-pinyin", { language = "zh", script = "Latn", variant = "pinyin" } },
{ "sl-rozaj-biske", { language = "sl", variant = { "rozaj", "biske" } } },
{ "sl-rozaj-biske-1994", { language = "sl", variant = { "rozaj", "biske", "1994" } } },
{ "en-CA-newfound", { language = "en", region = "CA", variant = "newfound" } },
{ "ine-x-proto", { language = "ine", private_use = "proto" } },
-- Could be used to indicate the PIE transcription system used by Pokorny?
{ "ine-x-proto-pokorny", { language = "ine", private_use = { "proto", "pokorny" } } },
{ "x-fake-private-use", { private_use = { "fake", "private", "use" } } },
"errors",
{ "ine-!!!", { error = "invalid characters", invalid = "!!!" } },
{ "pâté", { error = "invalid characters", invalid = "pâté" } },
{ "Latn", { error = "no language subtag", invalid = "Latn" } },
{ "ru-Latn-Cyrl", { language = "ru", script = "Latn", error = "invalid subtag", invalid = "Cyrl" } },
{ "blahblahblah", { error = "no language subtag", invalid = "blahblahblah" } },
{ "ru-blahblahblah", { language = "ru", error = "invalid subtag", invalid = "blahblahblah" } },
{ "ru-Latn-blahblahblah",
{ language = "ru", script = "Latn", error = "invalid subtag", invalid = "blahblahblah" } },
{ "ru-x-blahblahblah",
{ language = "ru", error = "length of private-use subtag out of range", invalid = "x-blahblahblah" } },
{ "ru-x", { language = "ru", error = "empty private-use subtag", invalid = "x" } },
{ "blahblah-Latn", { error = "no language subtag", invalid = "blahblah-Latn" } },
{ "", nil },
-- { mw.log, nil },
-- { nil, nil },
}

local index = fun.indexOf("errors", examples)
table.insert(examples, index, "case-insensitivity")
for i = 1, index - 1 do -- Insert testcases for capitalized versions of the valid tags.
local upper_example = mw.clone(examples[i])
upper_example[1] = upper_example[1]:upper()
table.insert(examples, index + i, upper_example)
end

self:iterate(
examples,
function (self, IETF_code, expected)
self:equals(
('<code style="white-space: nowrap;">%s</code>'):format(IETF_code),
show_parsed_subtags(parse_IETF(IETF_code)),
show_parsed_subtags(expected))
end)
end

-- Change function names into more readable headers for the testcases tables.
for k, v in require "Module:TableTools".sortedPairs(p) do
if type(k) == "string" then
local new_k = k:gsub("^test_(.+)$", "testcases for <code>%1</code>")
if new_k ~= k then
p[k] = nil
p[new_k] = v
end
end
end

return p

Module:Sandbox/Erutuon/testcases - Revision history

imported>Erutuon: Module:Table → Module:TableTools