Moduuli:Mallinetyokalut/testit

Moduulin Mallinetyokalut/testit käyttöohje

Moduuli:Kielilinkki

✗ 1 testi epäonnistui.

	Testi	Odotettu	Tulos
✓	test numeroidut_parametrit ilman välinumeroita
✓	test numeroidut_parametrit ilman ykköstä
✗	test numeroidut_parametrit tyhjillä	table#1 { ["mon"] = table#2 { "testi1", "testi3", }, }	table#1 { ["mon"] = table#2 { "testi1", "", "testi3", }, }
✓	test poista_tyhjat poistaa tyhjät nimetyt arvot
✓	test poista_tyhjat poistaa tyhjät numeroidut arvot
✓	test ryhmittele_prefikseittain niputtaa prefiksin mukaan
✓	test ryhmittele_prefikseittain niputtaa prefiksittömät 0:aan
✓	test ryhmittele_prefikseittain, kun prefiksi on toisen osa
✓	test_ensimmainen_ei_tyhja
✓	test_ensimmainen_ei_tyhja_nollaa
✓	test_map
✓	test_numeroidut_parametrit
✓	test_numeroidut_parametrit_kaksi_tasoa

Hiekkalaatikko

✗ 1 testi epäonnistui.

	Testi	Odotettu	Tulos
✓	test numeroidut_parametrit ilman välinumeroita
✓	test numeroidut_parametrit ilman ykköstä
✗	test numeroidut_parametrit tyhjillä	table#1 { ["mon"] = table#2 { "testi1", "testi3", }, }	table#1 { ["mon"] = table#2 { "testi1", "", "testi3", }, }
✓	test poista_tyhjat poistaa tyhjät nimetyt arvot
✓	test poista_tyhjat poistaa tyhjät numeroidut arvot
✓	test ryhmittele_prefikseittain niputtaa prefiksin mukaan
✓	test ryhmittele_prefikseittain niputtaa prefiksittömät 0:aan
✓	test ryhmittele_prefikseittain, kun prefiksi on toisen osa
✓	test_ensimmainen_ei_tyhja
✓	test_ensimmainen_ei_tyhja_nollaa
✓	test_map
✓	test_numeroidut_parametrit
✓	test_numeroidut_parametrit_kaksi_tasoa

---

-- Yksikkötestit moduulille [[Moduuli:Mallinetyokalut]].

local ScribuntoUnit = require("Module:ScribuntoUnit")
local suite = ScribuntoUnit:new()

local libName = "Mallinetyokalut"


-- Helper to run all tests using sandbox version of the library from the debug console. To run against main lib, use  =p.run()
function suite.runSandbox()
    local frame = mw.getCurrentFrame():newChild{title="testit", args={module=libName .. "/hiekkalaatikko", displayMode="log"}}
    return suite.run(frame)
end

-- Allow test runner to use the sandbox and the primary versions of the library with the same testcases
function suite:module()
    return require("Moduuli:" .. (self.frame and self.frame.args and self.frame.args.module or libName))
end



------------------------------------------------------------------------
-- Test map-funktio
------------------------------------------------------------------------

function suite:test_map()
    local m = self:module()
    
    self:assertDeepEquals({ "A", "B", "C" }, m.map(function (item) return string.upper(item) end, { "a", "b", "c" }))
    self:assertDeepEquals({ "A" }, m.map(function (item) return string.upper(item) end, { "a" }))
    self:assertEquals(0, #m.map(function (item) return string.upper(item) end, { }))
    
end

------------------------------------------------------------------------
-- Test ensimmainen_ei_tyhja -funktio
------------------------------------------------------------------------

function suite:test_ensimmainen_ei_tyhja()
    local m = self:module()

    self:assertEquals("a", m.ensimmainen_ei_tyhja{"a", "b", "c"})
    self:assertEquals("b", m.ensimmainen_ei_tyhja{"", "b", "c"})
    self:assertEquals("b", m.ensimmainen_ei_tyhja{nil, "b", "c"})
    self:assertEquals("c", m.ensimmainen_ei_tyhja{"", nil, "c"})
    self:assertEquals("c", m.ensimmainen_ei_tyhja{nil, "", "c"})
    
end

------------------------------------------------------------------------
-- Test ensimmainen_ei_tyhja -funktio "nollaa" tyhjän merkkijonon 
------------------------------------------------------------------------

function suite:test_ensimmainen_ei_tyhja_nollaa()
    local m = self:module()

    self:assertEquals(nil, m.ensimmainen_ei_tyhja{""})
    self:assertEquals(nil, m.ensimmainen_ei_tyhja{nil})
    self:assertEquals("a", m.ensimmainen_ei_tyhja{"a"})
    self:assertEquals(nil, m.ensimmainen_ei_tyhja{"", nil})
    self:assertEquals(nil, m.ensimmainen_ei_tyhja{nil, ""})
    
end


------------------------------------------------------------------------
-- Test numeroidut_parametrit -funktio
------------------------------------------------------------------------

function suite:test_numeroidut_parametrit()
    local m = self:module()

    self:assertDeepEquals({ mon = { "testi1", "testi2", "testi3" } }, m.numeroidut_parametrit(
            {
                mon1 = "testi1",
                mon2 = "testi2",
                mon3 = "testi3"
            },
            {
                "mon"
            }
    ))
end

suite["test numeroidut_parametrit ilman välinumeroita"] = function (self)
	    local m = self:module()

    self:assertDeepEquals({ mon = { "testi1", "testi3" } }, m.numeroidut_parametrit(
            {
                mon1 = "testi1",
                mon3 = "testi3"
            },
            {
                "mon"
            }
    ))
end

suite["test numeroidut_parametrit tyhjillä"] = function (self)
	    local m = self:module()

    self:assertDeepEquals({ mon = { "testi1", "testi3" } }, m.numeroidut_parametrit(
            {
                mon1 = "testi1",
                mon2 = "",
                mon3 = "testi3"
            },
            {
                "mon"
            }
    ))
end

suite["test numeroidut_parametrit ilman ykköstä"] = function (self)
    local m = self:module()
    
    self:assertDeepEquals({ mon = { "testi1" } }, m.numeroidut_parametrit(
            {
                mon = "testi1"
            },
            {
                "mon"
            }
    ))

    self:assertDeepEquals({ mon = { "testi1", "testi2" } }, m.numeroidut_parametrit(
            {
                mon  = "testi1",
                mon2 = "testi2"
            },
            {
                "mon"
            }
    ))

end



function suite:test_numeroidut_parametrit_kaksi_tasoa()
    local m = self:module()

	local args = { 
    	["p1"] = "何", 
    	["plat1.1"] = "eka", 
    	["plat1.2"] = "toka", 
    	["p2"] = "مايو", 
    	["plat2.1"] = "kolkki" 
	}
	self:assertDeepEquals({ p = { "何", "مايو" }, plat = { { "eka", "toka" }, { "kolkki" } } }, m.numeroidut_parametrit(args, { "p", "plat" }))
		
end


suite["test ryhmittele_prefikseittain niputtaa prefiksin mukaan"] = function (self)
    local m = self:module()

    local input = {
        ["nom.m"]  = "blörgus",
        ["nom.f"]  = "blörga",
        ["nom.n"]  = "blörgum",
        ["komp.nom.m"] = "blörgämpus",
        ["komp.nom.f"] = "blörgämpa",
        ["komp.nom.n"] = "blörgämpum",
        ["sup.nom.m"]  = "blöginus",
        ["sup.nom.f"]  = "blörgina",
        ["sup.nom.n"]  = "blörginum",
    }
        
    local result = m.ryhmittele_prefikseittain(input, {
                                                   ["komp."] = "komp",
                                                   ["sup."] = "sup",
    })
    
    self:assertDeepEquals({
            ["nom.m"] = "blörgämpus",
            ["nom.f"] = "blörgämpa",
            ["nom.n"] = "blörgämpum"
    }, result["komp"])
    
    self:assertDeepEquals({
                ["nom.m"]  = "blöginus",
                ["nom.f"]  = "blörgina",
                ["nom.n"]  = "blörginum"
    }, result["sup"])
    
end



suite["test ryhmittele_prefikseittain niputtaa prefiksittömät 0:aan"] = function (self)
    local m = self:module()

    local input = {
        ["nom.m"]  = "blörgus",
        ["nom.f"]  = "blörga",
        ["nom.n"]  = "blörgum",
        ["komp.nom.m"] = "blörgämpus",
        ["komp.nom.f"] = "blörgämpa",
        ["komp.nom.n"] = "blörgämpum",
        ["sup.nom.m"]  = "blöginus",
        ["sup.nom.f"]  = "blörgina",
        ["sup.nom.n"]  = "blörginum",
    }
        
    local result = m.ryhmittele_prefikseittain(input, {
                                                   ["komp."] = "komp",
                                                   ["sup."] = "sup",
    })
    
    self:assertDeepEquals({
                ["nom.m"] = "blörgus",
                ["nom.f"]  = "blörga",
                ["nom.n"]  = "blörgum"
    }, result[0])
    
end

suite["test ryhmittele_prefikseittain, kun prefiksi on toisen osa"] = function (self)
    local m = self:module()

    local input = {
        ["nom.m"]  = "blörgus",
        ["nom.f"]  = "blörga",
        ["nom.n"]  = "blörgum",
        ["komp.nom.m"] = "blörgämpus",
        ["komp.nom.f"] = "blörgämpa",
        ["komp.nom.n"] = "blörgämpum",
        ["komp.testi.nom.m"]  = "blöginus",
        ["komp.testi.nom.f"]  = "blörgina",
        ["komp.testi.nom.n"]  = "blörginum",
    }
        
    local result = m.ryhmittele_prefikseittain(input, {
                                                   ["komp."] = "komp",
                                                   ["komp.testi."] = "komp.testi",
    })

    self:assertDeepEquals({
            [0] = {
                ["nom.m"] = "blörgus",
                ["nom.f"]  = "blörga",
                ["nom.n"]  = "blörgum"
            },
            ["komp"] = {
                ["nom.m"] = "blörgämpus",
                ["nom.f"] = "blörgämpa",
                ["nom.n"] = "blörgämpum"
            },
            ["komp.testi"] = {
                ["nom.m"]  = "blöginus",
                ["nom.f"]  = "blörgina",
                ["nom.n"]  = "blörginum"
            }
    }, result)
    
end

suite["test poista_tyhjat poistaa tyhjät nimetyt arvot"] = function (self)
	local m = self:module()

    self:assertDeepEquals({
                        ["y.nom"] = "uugi",
                        ["y.part"] = "buugi"
	}, m.poista_tyhjat({
                        ["y.nom"] = "uugi",
                        ["y.gen"] = "",
                        ["y.part"] = "buugi"
	}))

end

suite["test poista_tyhjat poistaa tyhjät numeroidut arvot"] = function (self)
	local m = self:module()

	self:assertDeepEquals({ "uugi", "buugi" }, m.poista_tyhjat({ "uugi", "", "buugi" }))
end

return suite