Moduuli:tavutus/fi/testit
< Moduuli:tavutus | fi
Moduulin tavutus/fi/testit käyttöohje [näytä tämä käyttöohje omalla sivullaan] [muokkaa tätä käyttöohjetta] [päivitä] [testit] [hiekkalaatikko]
✓ Kaikki testit läpäisty.
| Testi | Odotettu | Tulos | |
|---|---|---|---|
| ✓ | testi Bonusmateriaali | ||
| ✓ | testi CV-yhtymä aloittaa tavun | ||
| ✓ | testi Ei-ascii-konsonantit | ||
| ✓ | testi Heittomerkki (') toimii tavurajana | ||
| ✓ | testi Heittomerkki (’) toimii tavurajana | ||
| ✓ | testi Kadon aiheuttama diftongi voidaan hahmottaa diftongina ja vokaaliyhtymänä | ||
| ✓ | testi Kolmen peräkkäistä vokaalia | ||
| ✓ | testi Neljä peräkkäistä vokaalia | ||
| ✓ | testi Pitkä vokaali + vokaali | ||
| ✓ | testi Sana voi alkaa isolla kirjaimella | ||
| ✓ | testi Sana voi alkaa monella konsonantilla | ||
| ✓ | testi Sana voi alkaa vokaalilla | ||
| ✓ | testi Tavuraja sellaisten vokaalien välissä, jotka eivät muodosta diftongia | ||
| ✓ | testi Tavutukseen voi vaikuttaa tavurajavihjeillä | ||
| ✓ | testi Vokaali + pitkä vokaali | ||
| ✓ | testi Yhdyssanojen rajat voi antaa #-merkillä | ||
| ✓ | testi Yhdyssanojen rajat voi antaa plusmerkillä | ||
| ✓ | testi Yhdyssanojen rajat voi antaa yhdysmerkillä | ||
| ✓ | testi ie ensitavussa on diftongi | ||
| ✓ | testi u- ja y-päätteiset diftongit ensitavun jälkeen voi hahmottaa diftongina tai vokaaliyhtymänä |
-- Unit tests for [[Module:fi-tavutus]]. Click talk page to run tests.
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()
local libName = 'tavutus/fi'
-- 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.module or libName))
end
--[[
Library-specific tests
]]
local function helper1(m, word)
return table.concat(m.tavutettu_teksti(word)[1], "-")
end
local function helper2(m, word)
return table.concat(m.tavutettu_teksti(word)[2], "-")
end
suite["testi CV-yhtymä aloittaa tavun"] = function (self)
local m = self:module()
self:assertEquals("ka-la", helper1(m, "kala"))
self:assertEquals("kui-ten-kin", helper1(m, "kuitenkin"))
self:assertEquals("kurs-si", helper1(m, "kurssi"))
self:assertEquals("ken-gät", helper1(m, "kengät"))
self:assertEquals("tär-ke-ää", helper1(m, "tärkeää"))
end
suite["testi Sana voi alkaa monella konsonantilla"] = function (self)
local m = self:module()
self:assertEquals("pro-sent-ti", helper1(m, "prosentti"))
self:assertEquals("stra-te-gi-a", helper1(m, "strategia"))
self:assertEquals("stres-si", helper1(m, "stressi"))
end
suite["testi Sana voi alkaa vokaalilla"] = function (self)
local m = self:module()
self:assertEquals("o-me-na", helper1(m, "omena"))
self:assertEquals("a-si-a", helper1(m, "asia"))
self:assertEquals("a-bort-ti", helper1(m, "abortti"))
self:assertEquals("a-lu-eet", helper1(m, "alueet"))
self:assertEquals("al-ka-en", helper1(m, "alkaen"))
self:assertEquals("up-po-a-ma", helper1(m, "uppoama"))
end
suite["testi Sana voi alkaa isolla kirjaimella"] = function (self)
local m = self:module()
self:assertEquals("Hilk-ka", helper1(m, "Hilkka"))
self:assertEquals("Erk-ki", helper1(m, "Erkki"))
self:assertEquals("Mii-a", helper1(m, "Miia"))
end
suite["testi u- ja y-päätteiset diftongit ensitavun jälkeen voi hahmottaa diftongina tai vokaaliyhtymänä"] = function (self)
local m = self:module()
-- http://www.kielitoimistonohjepankki.fi/ohje/357
local tulokset = m.tavutettu_teksti("tilaukset")
self:assertEquals(table.concat(tulokset[2], "-"), "ti-lauk-set")
tulokset = m.tavutettu_teksti("vapauttaa")
self:assertEquals(table.concat(tulokset[1], "-"), "va-pa-ut-taa")
self:assertEquals(table.concat(tulokset[2], "-"), "va-paut-taa")
tulokset = m.tavutettu_teksti("talous")
self:assertEquals(table.concat(tulokset[1], "-"), "ta-lo-us")
self:assertEquals(table.concat(tulokset[2], "-"), "ta-lous")
tulokset = m.tavutettu_teksti("nopeus")
self:assertEquals(table.concat(tulokset[1], "-"), "no-pe-us")
self:assertEquals(table.concat(tulokset[2], "-"), "no-peus")
tulokset = m.tavutettu_teksti("palautus")
self:assertEquals(table.concat(tulokset[1], "-"), "pa-lau-tus")
self:assertEquals(table.concat(tulokset[2], "-"), "pa-la-u-tus")
tulokset = m.tavutettu_teksti("hyökkäyksen")
self:assertEquals(table.concat(tulokset[1], "-"), "hyök-kä-yk-sen")
self:assertEquals(table.concat(tulokset[2], "-"), "hyök-käyk-sen")
tulokset = m.tavutettu_teksti("rakkautta")
self:assertEquals(table.concat(tulokset[1], "-"), "rak-ka-ut-ta")
self:assertEquals(table.concat(tulokset[2], "-"), "rak-kaut-ta")
tulokset = m.tavutettu_teksti("vihkiytyä")
self:assertEquals(table.concat(tulokset[1], "-"), "vih-kiy-ty-ä")
self:assertEquals(table.concat(tulokset[2], "-"), "vih-ki-y-ty-ä")
end
suite["testi Yhdyssanojen rajat voi antaa yhdysmerkillä"] = function (self)
local m = self:module()
self:assertEquals("pää-a-si-a", helper1(m, "pää-asia"))
self:assertEquals("y-li-o-pis-to", helper1(m, "yli-opisto"))
self:assertEquals("bi-o-die-sel", helper1(m, "bio-diesel"))
self:assertEquals("e-rin-o-mais-ta", helper1(m, "erin-omaista"))
self:assertEquals("kan-ta-e-si-tys", helper1(m, "kanta-esitys"))
self:assertEquals("kie-li-a-si-an-tun-ti-ja", helper1(m, "kieli-asian-tuntija"))
self:assertEquals("vi-ran-o-mai-nen", helper1(m, "viran-omainen"))
self:assertEquals("si-ka-nau-ta-jau-he-li-ha", helper1(m, "sika-nauta-jauhe-liha"))
self:assertEquals("Pi-rit-ta-kah-vi-la", helper1(m, "Piritta-kahvila"))
self:assertEquals("Erk-ki-se-tä", helper1(m, "Erkki-setä"))
end
suite["testi Yhdyssanojen rajat voi antaa plusmerkillä"] = function (self)
local m = self:module()
self:assertEquals("pää-a-si-a", helper1(m, "pää+asia"))
self:assertEquals("y-li-o-pis-to", helper1(m, "yli+opisto"))
self:assertEquals("bi-o-die-sel", helper1(m, "bio+diesel"))
self:assertEquals("e-rin-o-mais-ta", helper1(m, "erin+omaista"))
self:assertEquals("kan-ta-e-si-tys", helper1(m, "kanta+esitys"))
self:assertEquals("kie-li-a-si-an-tun-ti-ja", helper1(m, "kieli+asian+tuntija"))
self:assertEquals("vi-ran-o-mai-nen", helper1(m, "viran+omainen"))
end
suite["testi Yhdyssanojen rajat voi antaa #-merkillä"] = function (self)
local m = self:module()
self:assertEquals("pää-a-si-a", helper1(m, "pää#asia"))
self:assertEquals("y-li-o-pis-to", helper1(m, "yli#opisto"))
self:assertEquals("bi-o-die-sel", helper1(m, "bio#diesel"))
self:assertEquals("e-rin-o-mais-ta", helper1(m, "erin#omaista"))
self:assertEquals("kan-ta-e-si-tys", helper1(m, "kanta#esitys"))
self:assertEquals("vi-ran-o-mai-nen", helper1(m, "viran#omainen"))
self:assertEquals("kie-li-a-si-an-tun-ti-ja", helper1(m, "kieli#asian+tuntija"))
end
suite["testi Kadon aiheuttama diftongi voidaan hahmottaa diftongina ja vokaaliyhtymänä"] = function (self)
local m = self:module()
local result
-- http://www.kielitoimistonohjepankki.fi/ohje/154
-- (SKAM, s. 89–90)
result = m.tavutettu_teksti("i0en")
self:assertTrue(#result == 2)
self:assertEquals(table.concat(result[2], "-"), "ien")
result = m.tavutettu_teksti("hi0en")
self:assertTrue(#result == 2)
self:assertEquals(table.concat(result[1], "-"), "hi-en")
self:assertEquals(table.concat(result[2], "-"), "hien")
result = m.tavutettu_teksti("pi0en")
self:assertTrue(#result == 2)
self:assertEquals(table.concat(result[1], "-"), "pi-en")
self:assertEquals(table.concat(result[2], "-"), "pien")
result = m.tavutettu_teksti("la0in")
self:assertTrue(#result == 2)
self:assertEquals(table.concat(result[1], "-"), "la-in")
self:assertEquals(table.concat(result[2], "-"), "lain")
result = m.tavutettu_teksti("vi0an")
self:assertTrue(#result == 1)
self:assertEquals(table.concat(result[1], "-"), "vi-an")
result = m.tavutettu_teksti("hau0issa")
self:assertTrue(#result == 1)
self:assertEquals(table.concat(result[1], "-"), "hau-is-sa")
result = m.tavutettu_teksti("ha0uissa")
self:assertTrue(#result == 1)
self:assertEquals(table.concat(result[1], "-"), "ha-uis-sa")
result = m.tavutettu_teksti("ruo0issa")
self:assertTrue(#result == 1)
self:assertEquals(table.concat(result[1], "-"), "ruo-is-sa")
result = m.tavutettu_teksti("ru0oissa")
self:assertTrue(#result == 1)
self:assertEquals(table.concat(result[1], "-"), "ru-ois-sa")
result = m.tavutettu_teksti("te0os")
self:assertTrue(#result == 1)
self:assertEquals(table.concat(result[1], "-"), "te-os")
end
suite["testi Tavuraja sellaisten vokaalien välissä, jotka eivät muodosta diftongia"] = function (self)
local m = self:module()
self:assertEquals("pi-an", helper1(m, "pian"))
self:assertEquals("ra-e", helper1(m, "rae"))
self:assertEquals("ko-e", helper1(m, "koe"))
self:assertEquals("ai-no-a", helper1(m, "ainoa"))
self:assertEquals("hert-tu-aa", helper1(m, "herttuaa"))
self:assertEquals("köy-hi-en", helper1(m, "köyhien"))
self:assertEquals("puo-lu-ei-ta", helper1(m, "puolueita"))
self:assertEquals("pi-a-no", helper1(m, "piano"))
self:assertEquals("bi-o-lo-gi", helper1(m, "biologi"))
self:assertEquals("ge-o-met-ri-a", helper1(m, "geometria"))
self:assertEquals("Pi-a", helper1(m, "Pia"))
self:assertEquals("Tii-a", helper1(m, "Tiia"))
self:assertEquals("Le-o", helper1(m, "Leo"))
self:assertEquals("Jo-el", helper1(m, "Joel"))
self:assertEquals("se-as-sa", helper1(m, "seassa"))
self:assertEquals("di-a", helper1(m, "dia"))
self:assertEquals("re-a-lis-ti-nen", helper1(m, "realistinen"))
self:assertEquals("ko-a-li-ti-o", helper1(m, "koalitio"))
end
suite["testi Heittomerkki (’) toimii tavurajana"] = function (self)
local m = self:module()
self:assertEquals("vaa-an", helper1(m, "vaa’an"))
self:assertEquals("ko-ois-sa", helper1(m, "ko’oissa"))
self:assertEquals("rei-it-tää", helper1(m, "rei’ittää"))
self:assertEquals("ruo-on", helper1(m, "ruo’on"))
self:assertEquals("nau-un", helper1(m, "nau’un"))
self:assertEquals("liu-un", helper1(m, "liu’un"))
self:assertEquals("i-is-sä", helper1(m, "i’issä"))
self:assertEquals("hi-is-sä", helper1(m, "hi’issä"))
self:assertEquals("pi-is-sä", helper1(m, "pi’issä"))
end
suite["testi Heittomerkki (') toimii tavurajana"] = function (self)
local m = self:module()
self:assertEquals("vaa-an", helper1(m, "vaa'an"))
self:assertEquals("ko-ois-sa", helper1(m, "ko'oissa"))
self:assertEquals("rei-it-tää", helper1(m, "rei'ittää"))
self:assertEquals("ruo-on", helper1(m, "ruo'on"))
self:assertEquals("nau-un", helper1(m, "nau'un"))
self:assertEquals("liu-un", helper1(m, "liu'un"))
self:assertEquals("i-is-sä", helper1(m, "i'issä"))
self:assertEquals("hi-is-sä", helper1(m, "hi'issä"))
self:assertEquals("pi-is-sä", helper1(m, "pi'issä"))
end
suite["testi Tavutukseen voi vaikuttaa tavurajavihjeillä"] = function (self)
local m = self:module()
--- http://www.kielitoimistonohjepankki.fi/ohje/155
self:assertEquals("kon-struk-ti-o", helper1(m, "kon.struktio"))
self:assertEquals("konst-ruk-ti-o", helper1(m, "konstruktio"))
self:assertEquals("eks-tra", helper1(m, "eks.tra"))
self:assertEquals("ekst-ra", helper1(m, "ekstra"))
self:assertEquals("es-pla-na-di", helper1(m, "es.planadi"))
self:assertEquals("esp-la-na-di", helper1(m, "esplanadi"))
self:assertEquals("hams-traa-ja", helper1(m, "hams.traaja"))
self:assertEquals("hamst-raa-ja", helper1(m, "hamstraaja"))
self:assertEquals("es-pres-so", helper1(m, "es.presso"))
self:assertEquals("esp-res-so", helper1(m, "espresso"))
self:assertEquals("eks-pres-sii-vi-nen", helper1(m, "eks.pressiivinen"))
self:assertEquals("eksp-res-sii-vi-nen", helper1(m, "ekspressiivinen"))
self:assertEquals("ka-ta-stro-fi", helper1(m, "kata.strofi"))
self:assertEquals("ka-tast-ro-fi", helper1(m, "katastrofi"))
self:assertEquals("abs-trak-ti", helper1(m, "abs.trakti"))
self:assertEquals("abst-rak-ti", helper1(m, "abstrakti"))
self:assertEquals("de-skrip-ti-o", helper1(m, "de.skriptio"))
self:assertEquals("desk-rip-ti-o", helper1(m, "deskriptio"))
self:assertEquals("in-flaa-ti-o", helper1(m, "in.flaatio"))
self:assertEquals("inf-laa-ti-o", helper1(m, "inflaatio"))
self:assertEquals("Cast-ren", helper1(m, "Castren"))
self:assertEquals("A-lek-sand-ra", helper1(m, "Aleksandra"))
self:assertEquals("Ra-jevs-ki", helper1(m, "Rajevski"))
self:assertEquals("Bon-niin", helper1(m, "Bonniin"))
self:assertEquals("Lönn-ro-tin", helper1(m, "Lönnrotin"))
self:assertEquals("Snell-ma-nin", helper1(m, "Snellmanin"))
self:assertEquals("From-min", helper1(m, "Frommin"))
self:assertEquals("Por-than", helper1(m, "Por.than"))
self:assertEquals("Man-ches-ter", helper1(m, "Man.chester"))
self:assertEquals("Bang-la-de-shis-sa", helper1(m, "Banglade.shissa"))
self:assertEquals("Li-ving-sto-ne-a", helper1(m, "Living.stonea"))
self:assertEquals("Lind-ström", helper1(m, "Lind.ström"))
self:assertEquals("Wa-sa-stjer-na", helper1(m, "Wasa.stjerna"))
self:assertEquals("Sha-ke-spe-a-re", helper1(m, "Shake.speare"))
self:assertEquals("Ö-re-bro", helper1(m, "Öre.bro"))
self:assertEquals("Ports-mouth", helper2(m, "Ports.mouth"))
end
suite["testi CV-yhtymä aloittaa tavun"] = function (self)
local m = self:module()
self:assertEquals("ka-la", helper1(m, "kala"))
self:assertEquals("kui-ten-kin", helper1(m, "kuitenkin"))
self:assertEquals("kurs-si", helper1(m, "kurssi"))
self:assertEquals("ken-gät", helper1(m, "kengät"))
self:assertEquals("tär-ke-ää", helper1(m, "tärkeää"))
end
suite["testi ie ensitavussa on diftongi"] = function (self)
local m = self:module()
self:assertEquals("tie", helper1(m, "tie"))
self:assertEquals("tie-to", helper1(m, "tieto"))
self:assertEquals("ra-ja-tie-to", helper1(m, "raja#tieto"))
end
suite["testi Vokaali + pitkä vokaali"] = function (self)
local m = self:module()
self:assertEquals("mo-sa-iik-ki", helper1(m, "mosa.iikki"))
self:assertEquals("ka-oot-ti-nen", helper1(m, "kaoottinen"))
self:assertEquals("re-aa-li-nen", helper1(m, "reaalinen"))
self:assertEquals("ko-fe-ii-ni", helper1(m, "kofe.iini"))
self:assertEquals("di-eet-ti", helper1(m, "di.eetti"))
self:assertEquals("po-eet-ti-nen", helper1(m, "poeettinen"))
self:assertEquals("he-ro-ii-ni", helper1(m, "hero.iini"))
self:assertEquals("he-roo-i-nen", helper1(m, "herooinen"))
self:assertEquals("ja-gu-aa-ri", helper1(m, "jaguaari"))
self:assertEquals("be-du-ii-ni", helper1(m, "bedu.iini"))
self:assertEquals("vir-tu-oo-si", helper1(m, "virtuoosi"))
self:assertEquals("hy-ee-na", helper1(m, "hyeena"))
self:assertEquals("kor-ke-aa", helper1(m, "korkeaa"))
self:assertEquals("vei-ke-ää", helper1(m, "veikeää"))
self:assertEquals("ku-ti-aa", helper1(m, "kutiaa"))
self:assertEquals("val-ti-oon", helper1(m, "valtioon"))
self:assertEquals("mi-ni-ää", helper1(m, "miniää"))
self:assertEquals("yh-ti-öön", helper1(m, "yhtiöön"))
self:assertEquals("ai-no-aa", helper1(m, "ainoaa"))
self:assertEquals("ha-lu-aa", helper1(m, "haluaa"))
self:assertEquals("puo-lu-een", helper1(m, "puolueen"))
self:assertEquals("pe-sy-een", helper1(m, "pesyeen"))
self:assertEquals("kaa-ka-oon", helper1(m, "kaakaoon"))
self:assertEquals("puo-lu-een", helper1(m, "puolueen"))
self:assertEquals("pe-sy-een", helper1(m, "pesyeen"))
self:assertEquals("ny-ky-ään", helper1(m, "nykyään"))
self:assertEquals("kä-ry-ää", helper1(m, "käryää"))
self:assertEquals("nä-kö-ään", helper1(m, "näköään"))
end
suite["testi Kolmen peräkkäistä vokaalia"] = function (self)
local m = self:module()
self:assertEquals("maa-il-ma", helper1(m, "maailma"))
self:assertEquals("ai-e", helper1(m, "aie"))
self:assertEquals("kau-an", helper1(m, "kauan"))
self:assertEquals("au-er", helper1(m, "auer"))
self:assertEquals("o-mi-aan", helper1(m, "omiaan"))
self:assertEquals("to-si-aan", helper1(m, "tosiaan"))
self:assertEquals("am-pi-ai-nen", helper1(m, "ampiainen"))
self:assertEquals("ti-ai-nen", helper1(m, "tiainen"))
self:assertEquals("lii-an", helper1(m, "liian"))
self:assertEquals("ar-vi-oi", helper1(m, "arvioi"))
self:assertEquals("kiu-as", helper1(m, "kiuas"))
self:assertEquals("pää-si-äi-nen", helper1(m, "pääsiäinen"))
self:assertEquals("äy-ri-äi-nen", helper1(m, "äyriäinen"))
self:assertEquals("vi-he-ri-öi", helper1(m, "viheriöi"))
self:assertEquals("mu-nu-ai-nen", helper1(m, "munuainen"))
self:assertEquals("muu-al-la", helper1(m, "muualla"))
self:assertEquals("säi-e", helper1(m, "säie"))
self:assertEquals("kaa-os", helper1(m, "kaaos"))
end
suite["testi Pitkä vokaali + vokaali"] = function (self)
local m = self:module()
self:assertEquals("raa-an", helper1(m, "raa'an"))
self:assertEquals("raa-em-pi", helper1(m, "raa'empi"))
self:assertEquals("raa-im-mis-sa", helper1(m, "raa'immissa"))
self:assertEquals("raa-um-me", helper1(m, "raa'umme"))
self:assertEquals("lii-an", helper1(m, "liian"))
self:assertEquals("lii-e-tä", helper1(m, "liietä"))
self:assertEquals("pii-ot-te", helper1(m, "piiotte"))
self:assertEquals("rii-us-taa", helper1(m, "riiustaa"))
self:assertEquals("ruu-as-sa", helper1(m, "ruuassa"))
self:assertEquals("ruu-is-sa", helper1(m, "ruuissa"))
self:assertEquals("mää-it-te", helper1(m, "määitte"))
self:assertEquals("mää-yt-te", helper1(m, "määytte"))
end
suite["testi Neljä peräkkäistä vokaalia"] = function (self)
local m = self:module()
self:assertEquals("ai-oin", helper1(m, "aioin"))
self:assertEquals("kai-uis-sa", helper1(m, "kaiuissa"))
self:assertEquals("tau-ois-sa", helper1(m, "tauoissa"))
self:assertEquals("nau-uim-me", helper1(m, "nau'uimme"))
self:assertEquals("leu-ois-sa", helper1(m, "leuoissa"))
self:assertEquals("leu-uis-sa", helper1(m, "leu'uissa"))
self:assertEquals("lie-ois-sa", helper1(m, "lieoissa"))
self:assertEquals("kie-uit-te", helper1(m, "kieuitte"))
self:assertEquals("riu-uis-sa", helper1(m, "riu'uissa"))
self:assertEquals("loi-oim-me", helper1(m, "loioimme"))
self:assertEquals("joi-uis-sa", helper1(m, "joiuissa"))
self:assertEquals("ruo-ois-sa", helper1(m, "ruo'oissa"))
self:assertEquals("huo-uim-me", helper1(m, "huouimme"))
self:assertEquals("hyö-yis-sä", helper1(m, "hyöyissä"))
self:assertEquals("mää-yit-te", helper1(m, "määyitte"))
self:assertEquals("raa-ois-sa", helper1(m, "raaoissa"))
self:assertEquals("raa-uit-te", helper1(m, "raauitte"))
self:assertEquals("nii-ail-la", helper1(m, "niiailla"))
self:assertEquals("lii-ois-sa", helper1(m, "liioissa"))
end
suite["testi Ei-ascii-konsonantit"] = function (self)
local m = self:module()
self:assertEquals("šin-to", helper1(m, "šinto"))
self:assertEquals("dat-ša", helper1(m, "datša"))
self:assertEquals("džonk-ki", helper1(m, "džonkki"))
end
suite["testi Bonusmateriaali"] = function (self)
local m = self:module()
self:assertEquals("la-eis-sa", helper1(m, "laeissa"))
self:assertEquals("va-ois-sa", helper1(m, "vaoissa"))
self:assertEquals("hau-is-sa", helper1(m, "hauissa"))
self:assertEquals("hal-ke-ai-si", helper1(m, "halkeaisi"))
self:assertEquals("ho-pe-oi-da", helper1(m, "hopeoida"))
self:assertEquals("re-pe-äi-si", helper1(m, "repeäisi"))
self:assertEquals("li-pe-öi-dä", helper1(m, "lipeöidä"))
self:assertEquals("ku-ti-ai-si", helper1(m, "kutiaisi"))
self:assertEquals("val-ti-oi-ta", helper1(m, "valtioita"))
self:assertEquals("hi-ou-tu-a", helper1(m, "hioutua"))
self:assertEquals("sel-vi-äi-si", helper1(m, "selviäisi"))
self:assertEquals("mi-ni-öi-tä", helper1(m, "miniöitä"))
self:assertEquals("ko-ho-ai-si", helper1(m, "kohoaisi"))
self:assertEquals("ko-ois-sa", helper1(m, "ko'oissa"))
self:assertEquals("ha-lu-ai-si", helper1(m, "haluaisi"))
self:assertEquals("puo-lu-eis-sa", helper1(m, "puolueissa"))
self:assertEquals("saip-pu-oi-ta", helper1(m, "saippuoita"))
self:assertEquals("pe-sy-eis-sä", helper1(m, "pesyeissä"))
self:assertEquals("kä-ry-äi-si", helper1(m, "käryäisi"))
self:assertEquals("nä-yis-sä", helper1(m, "nä0yissä"))
self:assertEquals("nä-öis-sä", helper1(m, "näöissä"))
self:assertEquals("hi-ou-tu-a", helper1(m, "hioutua"))
self:assertEquals("tai-an", helper1(m, "taian"))
self:assertEquals("vai-e-ta", helper1(m, "vaieta"))
self:assertEquals("ai-on", helper1(m, "aion"))
self:assertEquals("kai-un", helper1(m, "kaiun"))
self:assertEquals("kau-an", helper1(m, "kauan"))
self:assertEquals("hau-en", helper1(m, "hauen"))
self:assertEquals("tau-on", helper1(m, "tauon"))
self:assertEquals("au-ot-te", helper1(m, "auotte"))
self:assertEquals("nau-ut-te", helper1(m, "nau'utte"))
self:assertEquals("rei-is-sä", helper1(m, "rei'issä"))
self:assertEquals("rei-än", helper1(m, "reiän"))
self:assertEquals("leu-an", helper1(m, "leuan"))
self:assertEquals("leu-un", helper1(m, "leu'un"))
self:assertEquals("lie-an", helper1(m, "liean"))
self:assertEquals("lie-on", helper1(m, "lieon"))
self:assertEquals("kie-ut-te", helper1(m, "kieutte"))
self:assertEquals("kiu-as", helper1(m, "kiuas"))
self:assertEquals("liu-e-ta", helper1(m, "liueta"))
self:assertEquals("liu-o-te", helper1(m, "liuote"))
self:assertEquals("tiu-un", helper1(m, "tiu'un"))
self:assertEquals("joi-a-ta", helper1(m, "joiata"))
self:assertEquals("oi-e-ta", helper1(m, "oieta"))
self:assertEquals("poi-it-te", helper1(m, "poi'itte"))
self:assertEquals("oi-om-me", helper1(m, "oiomme"))
self:assertEquals("joi-un", helper1(m, "joiun"))
self:assertEquals("lou-e", helper1(m, "loue"))
self:assertEquals("tou-on", helper1(m, "touon"))
self:assertEquals("hui-e-ta", helper1(m, "huieta"))
self:assertEquals("ruo-an", helper1(m, "ruoan"))
self:assertEquals("ruo-is-sa", helper1(m, "ruoissa"))
self:assertEquals("ruo-on", helper1(m, "ruo'on"))
self:assertEquals("huo-ut-te", helper1(m, "huoutte"))
self:assertEquals("hyö-ys-sä", helper1(m, "hyöyssä"))
self:assertEquals("säi-e", helper1(m, "säie"))
end
return suite