Toggle search
Toggle menu
15
236
70
27.5K
Kenshi Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Module:Userbox/testcases

From Kenshi Wiki
More actions
Refer to
Module:Userbox


--------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------
-- Unit tests for [[Module:Userbox/sandbox]]. Click talk page to run tests.
local ubx = require('Module:Userbox')
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()

local userbox = ubx['_userbox']
local userbox2 = ubx['_userbox-2']
local userboxr = ubx['_userbox-r']
local render = ubx.render
local categories = ubx.categories

--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------

local function inTag(s, tag)
	-- Makes a pattern that tests whether s is inside a given html tag.
	return '<' .. tag .. ' [^>]-' .. s
end

local function inAttr(s, attr)
	-- Makes a pattern that tests whether s is inside a given html attribute.
	return attr .. '="[^"]-' .. s
end

local function inTagAttr(s, tag, attr)
	-- Makes a pattern that tests whether s is inside a given html tag
	-- and a given html attribute.
	return inTag(inAttr(s, attr), tag)
end

local function renderId(data)
	data.showId = true
	return render(data)
end

local function renderId2(data)
	data.showId2 = true
	return render(data)
end

--------------------------------------------------------------------------------
-- Render tests
--------------------------------------------------------------------------------

function suite:testRenderFloat()
    self:assertStringContains(inTagAttr('float:right', 'div', 'style'), render{float = 'right'})
end

function suite:testRenderBorder()
    self:assertStringContains(inTagAttr('border:5px', 'div', 'style'), render{borderWidth = '5px'})
    self:assertStringContains('solid red', render{borderColor='red'})
end

function suite:testRenderMargin()
    self:assertStringContains(inTagAttr('margin:1px', 'div', 'style'), render{})
end

function suite:testRenderWidth()
    self:assertStringContains(inTagAttr('width:120px', 'div', 'style'), render{width = '120px'})
end

function suite:testRenderUserboxClass()
    self:assertStringContains(inTagAttr('wikipediauserbox', 'div', 'class'), render{})
end

function suite:testRenderBodyClass()
    self:assertStringContains(inTagAttr('foobar', 'div', 'class'), render{bodyClass = 'foobar'})
end

function suite:testRenderBorderCollapse()
    self:assertStringContains(inTagAttr('border-collapse:collapse', 'table', 'style'), render{})
end

function suite:testRenderBorderCollapse()
    self:assertStringContains(inTagAttr('width:120px', 'table', 'style'), render{width = '120px'})
end

function suite:testRenderTableWidth()
    self:assertStringContains(inTagAttr('width:120px', 'table', 'style'), render{width = '120px'})
end

function suite:testRenderMarginBottom()
    self:assertStringContains(inTagAttr('margin%-bottom:0', 'table', 'style'), render{})
end

function suite:testRenderBackgroundColor()
    self:assertStringContains(inTagAttr('background:red', 'table', 'style'), render{backgroundColor = 'red'})
end

--------------------------------------------------------------------------------
-- Render id tests
--------------------------------------------------------------------------------

function suite:testRenderIdBorder()
    self:assertStringContains(inTagAttr('border:0', 'td', 'style'), renderId{})
end

function suite:testRenderIdWidth()
    self:assertStringContains(inTagAttr('width:50px', 'td', 'style'), renderId{idWidth = '50px'})
end

function suite:testRenderIdHeight()
    self:assertStringContains(inTagAttr('height:50px', 'td', 'style'), renderId{idHeight = '50px'})
end

function suite:testRenderIdBackgroundColor()
    self:assertStringContains(inTagAttr('background:red', 'td', 'style'), renderId{idBackgroundColor = 'red'})
end

function suite:testRenderIdTextAlign()
    self:assertStringContains(inTagAttr('text%-align:center', 'td', 'style'), renderId{idTextAlign = 'center'})
end

function suite:testRenderIdFontSize()
    self:assertStringContains(inTagAttr('font%-size:16pt', 'td', 'style'), renderId{idFontSize = '16pt'})
end

function suite:testRenderIdColor()
    self:assertStringContains(inTagAttr('color:blue', 'td', 'style'), renderId{idColor = 'blue'})
end

function suite:testRenderIdPadding()
    self:assertStringContains(inTagAttr('padding:3px', 'td', 'style'), renderId{idPadding = '3px'})
end

function suite:testRenderIdLineHeight()
    self:assertStringContains(inTagAttr('line%-height:1.5em', 'td', 'style'), renderId{idLineHeight = '1.5em'})
end

function suite:testRenderIdVerticalAlign()
    self:assertStringContains(inTagAttr('vertical%-align:middle', 'td', 'style'), renderId{})
end

function suite:testRenderIdOtherParams()
    self:assertStringContains(inTagAttr('font%-family:serif', 'td', 'style'), renderId{idOtherParams = 'font-family:serif'})
end

function suite:testRenderIdClass()
    self:assertStringContains(inTagAttr('foobar', 'td', 'class'), renderId{idClass = 'foobar'})
end

function suite:testRenderId()
    self:assertStringContains('<td[^>]->Id text.</td>', renderId{id = 'Id text.'})
end

--------------------------------------------------------------------------------
-- Render info tests
--------------------------------------------------------------------------------

function suite:testRenderInfoBorder()
    self:assertStringContains(inTagAttr('border:0', 'td', 'style'), render{})
end

function suite:testRenderInfoTextAlign()
    self:assertStringContains(inTagAttr('text%-align:center', 'td', 'style'), render{infoTextAlign = 'center'})
end

function suite:testRenderInfoFontSize()
    self:assertStringContains(inTagAttr('font%-size:16pt', 'td', 'style'), render{infoFontSize = '16pt'})
end

function suite:testRenderInfoPadding()
    self:assertStringContains(inTagAttr('padding:3px', 'td', 'style'), render{infoPadding = '3px'})
end

function suite:testRenderInfoHeight()
    self:assertStringContains(inTagAttr('height:50px', 'td', 'style'), render{infoHeight = '50px'})
end

function suite:testRenderInfoLineHeight()
    self:assertStringContains(inTagAttr('line%-height:1.5em', 'td', 'style'), render{infoLineHeight = '1.5em'})
end

function suite:testRenderInfoColor()
    self:assertStringContains(inTagAttr('color:blue', 'td', 'style'), render{infoColor = 'blue'})
end

function suite:testRenderInfoVerticalAlign()
    self:assertStringContains(inTagAttr('vertical%-align:middle', 'td', 'style'), render{})
end

function suite:testRenderInfoOtherParams()
    self:assertStringContains(inTagAttr('font%-family:serif', 'td', 'style'), render{infoOtherParams = 'font-family:serif'})
end

function suite:testRenderInfoClass()
    self:assertStringContains(inTagAttr('foobar', 'td', 'class'), render{infoClass = 'foobar'})
end

function suite:testRenderInfo()
    self:assertStringContains('<td[^>]->Info text.</td>', render{info = 'Info text.'})
end

--------------------------------------------------------------------------------
-- Render id2 tests
--------------------------------------------------------------------------------

function suite:testRenderId2Border()
    self:assertStringContains(inTagAttr('border:0', 'td', 'style'), renderId2{})
end

function suite:testRenderId2Width()
    self:assertStringContains(inTagAttr('width:50px', 'td', 'style'), renderId2{id2Width = '50px'})
end

function suite:testRenderId2Height()
    self:assertStringContains(inTagAttr('height:50px', 'td', 'style'), renderId2{id2Height = '50px'})
end

function suite:testRenderId2BackgroundColor()
    self:assertStringContains(inTagAttr('background:red', 'td', 'style'), renderId2{id2BackgroundColor = 'red'})
end

function suite:testRenderId2TextAlign()
    self:assertStringContains(inTagAttr('text%-align:center', 'td', 'style'), renderId2{id2TextAlign = 'center'})
end

function suite:testRenderId2FontSize()
    self:assertStringContains(inTagAttr('font%-size:16pt', 'td', 'style'), renderId2{id2FontSize = '16pt'})
end

function suite:testRenderId2Color()
    self:assertStringContains(inTagAttr('color:blue', 'td', 'style'), renderId2{id2Color = 'blue'})
end

function suite:testRenderId2Padding()
    self:assertStringContains(inTagAttr('padding:3px', 'td', 'style'), renderId2{id2Padding = '3px'})
end

function suite:testRenderId2LineHeight()
    self:assertStringContains(inTagAttr('line%-height:1.5em', 'td', 'style'), renderId2{id2LineHeight = '1.5em'})
end

function suite:testRenderId2VerticalAlign()
    self:assertStringContains(inTagAttr('vertical%-align:middle', 'td', 'style'), renderId2{})
end

function suite:testRenderId2OtherParams()
    self:assertStringContains(inTagAttr('font%-family:serif', 'td', 'style'), renderId2{id2OtherParams = 'font-family:serif'})
end

function suite:testRenderId2()
    self:assertStringContains('<td[^>]->Id2 text.</td>', renderId2{id2 = 'Id2 text.'})
end

--------------------------------------------------------------------------------
-- Userbox div and table tag tests
--------------------------------------------------------------------------------

function suite:testUserboxFloat()
    self:assertEquals('left', userbox{}.float)
    self:assertEquals('right', userbox{float = 'right'}.float)
end

function suite:testUserboxBorderWidth()
    self:assertEquals('1px', userbox{}.borderWidth)
    self:assertEquals('2px', userbox{['border-width'] = '2'}.borderWidth)
    self:assertEquals('3px', userbox{['border-s'] = '3'}.borderWidth)
end

function suite:testUserboxBorderColor()
    self:assertEquals('#999', userbox{}.borderColor)
    self:assertEquals('red', userbox{['border-color'] = 'red'}.borderColor)
    self:assertEquals('yellow', userbox{[1] = 'yellow'}.borderColor)
    self:assertEquals('blue', userbox{['border-c'] = 'blue'}.borderColor)
    self:assertEquals('green', userbox{['id-c'] = 'green'}.borderColor)
end

function suite:testUserboxWidth()
    self:assertEquals('238px', userbox{}.width)
    self:assertEquals('236px', userbox{['border-s'] = '2'}.width)
end

function suite:testUserboxBodyClass()
    self:assertEquals(nil, userbox{}.bodyClass)
    self:assertEquals('foobar', userbox{bodyclass = 'foobar'}.bodyClass)
end

function suite:testUserboxBackgroundColor()
    self:assertEquals('#eee', userbox{}.backgroundColor)
    self:assertEquals('red', userbox{['info-background'] = 'red'}.backgroundColor)
    self:assertEquals('yellow', userbox{[2] = 'yellow'}.backgroundColor)
    self:assertEquals('blue', userbox{['info-c'] = 'blue'}.backgroundColor)
end

--------------------------------------------------------------------------------
-- Userbox id tests
--------------------------------------------------------------------------------

function suite:testUserboxId()
    self:assertEquals(nil, userbox{}.id)
    self:assertEquals('Id text.', userbox{logo = 'Id text.'}.id)
    self:assertEquals('More id text.', userbox{[3] = 'More id text.'}.id)
    self:assertEquals('Even more id text.', userbox{id = 'Even more id text.'}.id)
end

function suite:testUserboxShowId()
    self:assertEquals(true, userbox{id = 'Id text.'}.showId)
    self:assertEquals(false, userbox{}.showId)
end

function suite:testUserboxIdWidth()
    self:assertEquals('45px', userbox{}.idWidth)
    self:assertEquals('50px', userbox{['logo-width'] = '50'}.idWidth)
    self:assertEquals('55px', userbox{['id-w'] = '55'}.idWidth)
end

function suite:testUserboxIdHeight()
    self:assertEquals('45px', userbox{}.idHeight)
    self:assertEquals('50px', userbox{['logo-height'] = '50'}.idHeight)
    self:assertEquals('55px', userbox{['id-h'] = '55'}.idHeight)
end

function suite:testUserboxIdBackgroundColor()
    self:assertEquals('#ddd', userbox{}.idBackgroundColor)
    self:assertEquals('red', userbox{['logo-background'] = 'red'}.idBackgroundColor)
    self:assertEquals('yellow', userbox{[1] = 'yellow'}.idBackgroundColor)
    self:assertEquals('blue', userbox{['id-c'] = 'blue'}.idBackgroundColor)
end

function suite:testUserboxIdTextAlign()
    self:assertEquals('center', userbox{}.idTextAlign)
    self:assertEquals('right', userbox{['id-a'] = 'right'}.idTextAlign)
end

function suite:testUserboxIdFontSize()
    self:assertEquals('14pt', userbox{}.idFontSize)
    self:assertEquals('16pt', userbox{['logo-size'] = '16'}.idFontSize)
    self:assertEquals('18pt', userbox{[5] = '18'}.idFontSize)
    self:assertEquals('20pt', userbox{['id-s'] = '20'}.idFontSize)
end

function suite:testUserboxIdColor()
    self:assertEquals('black', userbox{}.idColor)
    self:assertEquals('red', userbox{['logo-color'] = 'red'}.idColor)
    self:assertEquals('blue', userbox{['id-fc'] = 'blue'}.idColor)
end

function suite:testUserboxIdPadding()
    self:assertEquals('0 1px 0 0', userbox{}.idPadding)
    self:assertEquals('1px 1px 1px 1px', userbox{['logo-padding'] = '1px 1px 1px 1px'}.idPadding)
    self:assertEquals('2px 2px 2px 2px', userbox{['id-p'] = '2px 2px 2px 2px'}.idPadding)
end

function suite:testUserboxIdLineHeight()
    self:assertEquals('1.25em', userbox{}.idLineHeight)
    self:assertEquals('1.5em', userbox{['logo-line-height'] = '1.5em'}.idLineHeight)
    self:assertEquals('1.75em', userbox{['id-lh'] = '1.75em'}.idLineHeight)
end

function suite:testUserboxIdOtherParams()
    self:assertEquals(nil, userbox{}.idOtherParams)
    self:assertEquals('font-family:serif', userbox{['logo-other-param'] = 'font-family:serif'}.idOtherParams)
    self:assertEquals('font-family:times', userbox{['id-op'] = 'font-family:times'}.idOtherParams)
end

function suite:testUserboxIdClass()
    self:assertEquals(nil, userbox{}.idClass)
    self:assertEquals('foobar', userbox{['id-class'] = 'foobar'}.idClass)
end

--------------------------------------------------------------------------------
-- Userbox info tests
--------------------------------------------------------------------------------

function suite:testUserboxInfo()
    self:assertEquals("<code>{{{info}}}</code>", userbox{}.info)
    self:assertEquals('Info text.', userbox{info = 'Info text.'}.info)
    self:assertEquals('More info text.', userbox{[4] = 'More info text.'}.info)
end

function suite:testUserboxInfoTextAlign()
    self:assertEquals('left', userbox{}.infoTextAlign)
    self:assertEquals('right', userbox{['info-a'] = 'right'}.infoTextAlign)
end

function suite:testUserboxInfoFontSize()
    self:assertEquals('8pt', userbox{}.infoFontSize)
    self:assertEquals('10pt', userbox{['info-size'] = '10'}.infoFontSize)
    self:assertEquals('12pt', userbox{['info-s'] = '12'}.infoFontSize)
end

function suite:testUserboxInfoHeight()
    self:assertEquals('45px', userbox{}.infoHeight)
    self:assertEquals('50px', userbox{['logo-height'] = '50'}.infoHeight)
    self:assertEquals('55px', userbox{['id-h'] = '55'}.infoHeight)
end

function suite:testUserboxInfoPadding()
    self:assertEquals('0 4px 0 4px', userbox{}.infoPadding)
    self:assertEquals('1px 1px 1px 1px', userbox{['info-padding'] = '1px 1px 1px 1px'}.infoPadding)
    self:assertEquals('2px 2px 2px 2px', userbox{['info-p'] = '2px 2px 2px 2px'}.infoPadding)
end

function suite:testUserboxInfoLineHeight()
    self:assertEquals('1.25em', userbox{}.infoLineHeight)
    self:assertEquals('1.5em', userbox{['info-line-height'] = '1.5em'}.infoLineHeight)
    self:assertEquals('1.75em', userbox{['info-lh'] = '1.75em'}.infoLineHeight)
end

function suite:testUserboxInfoColor()
    self:assertEquals('black', userbox{}.infoColor)
    self:assertEquals('red', userbox{['info-color'] = 'red'}.infoColor)
    self:assertEquals('blue', userbox{['info-fc'] = 'blue'}.infoColor)
end

function suite:testUserboxInfoOtherParams()
    self:assertEquals(nil, userbox{}.infoOtherParams)
    self:assertEquals('font-family:serif', userbox{['info-other-param'] = 'font-family:serif'}.infoOtherParams)
    self:assertEquals('font-family:times', userbox{['info-op'] = 'font-family:times'}.infoOtherParams)
end

function suite:testUserboxInfoClass()
    self:assertEquals(nil, userbox{}.infoClass)
    self:assertEquals('foobar', userbox{['info-class'] = 'foobar'}.infoClass)
end

--------------------------------------------------------------------------------
-- Userbox2 div and table tag tests
--------------------------------------------------------------------------------

function suite:testUserbox2Float()
    self:assertEquals('left', userbox2{}.float)
    self:assertEquals('right', userbox2{float = 'right'}.float)
end

function suite:testUserbox2BorderWidth()
    self:assertEquals('1px', userbox2{}.borderWidth)
    self:assertEquals('2px', userbox2{[9] = '2'}.borderWidth)
    self:assertEquals('3px', userbox2{['border-s'] = '3'}.borderWidth)
end


function suite:testUserbox2BorderColor()
    self:assertEquals('#999999', userbox2{}.borderColor)
    self:assertEquals('red', userbox2{[1] = 'red'}.borderColor)
    self:assertEquals('blue', userbox2{['border-c'] = 'blue'}.borderColor)
    self:assertEquals('green', userbox2{['id1-c'] = 'green'}.borderColor)
end


function suite:testUserbox2Width()
    self:assertEquals('238px', userbox2{}.width)
end

function suite:testUserbox2BodyClass()
    self:assertEquals(nil, userbox2{}.bodyClass)
    self:assertEquals('foobar', userbox2{bodyclass = 'foobar'}.bodyClass)
end

function suite:testUserbox2BackgroundColor()
    self:assertEquals('#eeeeee', userbox2{}.backgroundColor)
    self:assertEquals('yellow', userbox2{[2] = 'yellow'}.backgroundColor)
    self:assertEquals('blue', userbox2{['info-c'] = 'blue'}.backgroundColor)
end

--------------------------------------------------------------------------------
-- Userbox2 id tests
--------------------------------------------------------------------------------

function suite:testUserbox2Id()
    self:assertEquals('id1', userbox2{}.id)
    self:assertEquals('Id text.', userbox2{logo = 'Id text.'}.id)
    self:assertEquals('More id text.', userbox2{[3] = 'More id text.'}.id)
    self:assertEquals('Even more id text.', userbox2{id1 = 'Even more id text.'}.id)
end
function suite:testUserbox2ShowId()
    self:assertEquals(true, userbox2{}.showId)
end

function suite:testUserbox2IdWidth()
    self:assertEquals('45px', userbox2{}.idWidth)
    self:assertEquals('50px', userbox2{['id1-w'] = '50'}.idWidth)
end

function suite:testUserbox2IdHeight()
    self:assertEquals('45px', userbox2{}.idHeight)
    self:assertEquals('50px', userbox2{['id-h'] = '50'}.idHeight)
end

function suite:testUserbox2IdBackgroundColor()
    self:assertEquals('#dddddd', userbox2{}.idBackgroundColor)
    self:assertEquals('yellow', userbox2{[1] = 'yellow'}.idBackgroundColor)
    self:assertEquals('blue', userbox2{['id1-c'] = 'blue'}.idBackgroundColor)
end

function suite:testUserbox2IdTextAlign()
    self:assertEquals('center', userbox2{}.idTextAlign)
end

function suite:testUserbox2IdFontSize()
    self:assertEquals('14pt', userbox2{}.idFontSize)
    self:assertEquals('16pt', userbox2{['id1-s'] = '16'}.idFontSize)
end

function suite:testUserbox2IdLineHeight()
    self:assertEquals('1.25em', userbox2{}.idLineHeight)
    self:assertEquals('1.5em', userbox2{['id1-lh'] = '1.5em'}.idLineHeight)
end

function suite:testUserbox2IdColor()
    self:assertEquals('black', userbox2{}.idColor)
    self:assertEquals('blue', userbox2{['id1-fc'] = 'blue'}.idColor)
end

function suite:testUserbox2IdPadding()
    self:assertEquals('0 1px 0 0', userbox2{}.idPadding)
    self:assertEquals('1px 1px 1px 1px', userbox2{['id1-p'] = '1px 1px 1px 1px'}.idPadding)
end

function suite:testUserbox2IdOtherParams()
    self:assertEquals(nil, userbox2{}.idOtherParams)
    self:assertEquals('font-family:times', userbox2{['id1-op'] = 'font-family:times'}.idOtherParams)
end

--------------------------------------------------------------------------------
-- Userbox2 info tests
--------------------------------------------------------------------------------

function suite:testUserbox2Info()
    self:assertEquals("<code>{{{info}}}</code>", userbox2{}.info)
    self:assertEquals('Info text.', userbox2{[4] = 'Info text.'}.info)
    self:assertEquals('More info text.', userbox2{info = 'More info text.'}.info)
end

function suite:testUserbox2InfoTextAlign()
    self:assertEquals('left', userbox2{}.infoTextAlign)
    self:assertEquals('right', userbox2{['info-a'] = 'right'}.infoTextAlign)
end

function suite:testUserbox2InfoFontSize()
    self:assertEquals('8pt', userbox2{}.infoFontSize)
    self:assertEquals('10pt', userbox2{['info-s'] = '10'}.infoFontSize)
end

function suite:testUserbox2InfoColor()
    self:assertEquals('black', userbox2{}.infoColor)
    self:assertEquals('red', userbox2{[8] = 'red'}.infoColor)
    self:assertEquals('blue', userbox2{['info-fc'] = 'blue'}.infoColor)
end

function suite:testUserbox2InfoPadding()
    self:assertEquals('0 4px 0 4px', userbox2{}.infoPadding)
    self:assertEquals('1px 1px 1px 1px', userbox2{['info-p'] = '1px 1px 1px 1px'}.infoPadding)
end

function suite:testUserbox2InfoLineHeight()
    self:assertEquals('1.25em', userbox2{}.infoLineHeight)
    self:assertEquals('1.5em', userbox2{['info-lh'] = '1.5em'}.infoLineHeight)
end

function suite:testUserbox2InfoOtherParams()
    self:assertEquals(nil, userbox2{}.infoOtherParams)
    self:assertEquals('font-family:times', userbox2{['info-op'] = 'font-family:times'}.infoOtherParams)
end

--------------------------------------------------------------------------------
-- Userbox2 id2 tests
--------------------------------------------------------------------------------

function suite:testUserbox2Id2()
    self:assertEquals('id2', userbox2{}.id2)
    self:assertEquals('Id2 text.', userbox2{logo = 'Id2 text.'}.id2)
    self:assertEquals('More id2 text.', userbox2{[5] = 'More id2 text.'}.id2)
    self:assertEquals('Even more id2 text.', userbox2{id2 = 'Even more id2 text.'}.id2)
end

function suite:testUserbox2ShowId2()
    self:assertEquals(true, userbox2{}.showId2)
end

function suite:testUserbox2Id2Width()
    self:assertEquals('45px', userbox2{}.id2Width)
    self:assertEquals('50px', userbox2{['id2-w'] = '50'}.id2Width)
end

function suite:testUserbox2Id2Height()
    self:assertEquals('45px', userbox2{}.id2Height)
    self:assertEquals('50px', userbox2{['id-h'] = '50'}.id2Height)
end

function suite:testUserbox2Id2BackgroundColor()
    self:assertEquals('#dddddd', userbox2{}.id2BackgroundColor)
    self:assertEquals('yellow', userbox2{[7] = 'yellow'}.id2BackgroundColor)
    self:assertEquals('blue', userbox2{['id2-c'] = 'blue'}.id2BackgroundColor)
    self:assertEquals('red', userbox2{[1] = 'red'}.id2BackgroundColor)
end

function suite:testUserbox2Id2TextAlign()
    self:assertEquals('center', userbox2{}.id2TextAlign)
end

function suite:testUserbox2Id2FontSize()
    self:assertEquals('14pt', userbox2{}.id2FontSize)
    self:assertEquals('16pt', userbox2{['id2-s'] = '16'}.id2FontSize)
end

function suite:testUserbox2Id2LineHeight()
    self:assertEquals('1.25em', userbox2{}.id2LineHeight)
    self:assertEquals('1.5em', userbox2{['id2-lh'] = '1.5em'}.id2LineHeight)
end

function suite:testUserbox2Id2Color()
    self:assertEquals('black', userbox2{}.id2Color)
    self:assertEquals('blue', userbox2{['id2-fc'] = 'blue'}.id2Color)
end

function suite:testUserbox2Id2Padding()
    self:assertEquals('0 0 0 1px', userbox2{}.id2Padding)
    self:assertEquals('1px 1px 1px 1px', userbox2{['id2-p'] = '1px 1px 1px 1px'}.id2Padding)
end

function suite:testUserbox2Id2OtherParams()
    self:assertEquals(nil, userbox2{}.id2OtherParams)
    self:assertEquals('font-family:times', userbox2{['id2-op'] = 'font-family:times'}.id2OtherParams)
end

--------------------------------------------------------------------------------
-- Userboxr div and table tag tests
--------------------------------------------------------------------------------

function suite:testUserboxrFloat()
    self:assertEquals('left', userboxr{}.float)
    self:assertEquals('right', userboxr{float = 'right'}.float)
end

function suite:testUserboxrBorderWidth()
    self:assertEquals('1px', userboxr{}.borderWidth)
    self:assertEquals('2px', userboxr{['border-width'] = '2'}.borderWidth)
    self:assertEquals('3px', userboxr{['border-s'] = '3'}.borderWidth)
end

function suite:testUserboxrBorderColor()
    self:assertEquals('#999', userboxr{}.borderColor)
    self:assertEquals('red', userboxr{['border-color'] = 'red'}.borderColor)
    self:assertEquals('yellow', userboxr{[1] = 'yellow'}.borderColor)
    self:assertEquals('blue', userboxr{['border-c'] = 'blue'}.borderColor)
    self:assertEquals('green', userboxr{['id-c'] = 'green'}.borderColor)
end


function suite:testUserboxrWidth()
    self:assertEquals('238px', userboxr{}.width)
end

function suite:testUserboxrBodyClass()
    self:assertEquals(nil, userboxr{}.bodyClass)
    self:assertEquals('foobar', userboxr{bodyclass = 'foobar'}.bodyClass)
end

function suite:testUserboxrBackgroundColor()
    self:assertEquals('#eee', userboxr{}.backgroundColor)
    self:assertEquals('red', userboxr{['info-background'] = 'red'}.backgroundColor)
    self:assertEquals('yellow', userboxr{[2] = 'yellow'}.backgroundColor)
    self:assertEquals('blue', userboxr{['info-c'] = 'blue'}.backgroundColor)
end

--------------------------------------------------------------------------------
-- Userboxr info tests
--------------------------------------------------------------------------------

function suite:testUserboxrInfo()
    self:assertEquals("<code>{{{info}}}</code>", userboxr{}.info)
    self:assertEquals('Info text.', userboxr{info = 'Info text.'}.info)
    self:assertEquals('More info text.', userboxr{[4] = 'More info text.'}.info)
end
function suite:testUserboxrInfoTextAlign()
    self:assertEquals('left', userboxr{}.infoTextAlign)
    self:assertEquals('right', userboxr{['info-align'] = 'right'}.infoTextAlign)
    self:assertEquals('center', userboxr{['info-a'] = 'center'}.infoTextAlign)
end

function suite:testUserboxrInfoFontSize()
    self:assertEquals('8pt', userboxr{}.infoFontSize)
    self:assertEquals('10pt', userboxr{['info-size'] = '10'}.infoFontSize)
    self:assertEquals('12pt', userboxr{['info-s'] = '12'}.infoFontSize)
end


function suite:testUserboxrInfoPadding()
    self:assertEquals('0 4px 0 4px', userboxr{}.infoPadding)
    self:assertEquals('1px 1px 1px 1px', userboxr{['info-padding'] = '1px 1px 1px 1px'}.infoPadding)
    self:assertEquals('2px 2px 2px 2px', userboxr{['info-p'] = '2px 2px 2px 2px'}.infoPadding)
end

function suite:testUserboxrInfoLineHeight()
    self:assertEquals('1.25em', userboxr{}.infoLineHeight)
    self:assertEquals('1.5em', userboxr{['info-line-height'] = '1.5em'}.infoLineHeight)
    self:assertEquals('1.75em', userboxr{['info-lh'] = '1.75em'}.infoLineHeight)
end


function suite:testUserboxrInfoColor()
    self:assertEquals('black', userboxr{}.infoColor)
    self:assertEquals('red', userboxr{['info-color'] = 'red'}.infoColor)
    self:assertEquals('blue', userboxr{['info-fc'] = 'blue'}.infoColor)
end

function suite:testUserboxrInfoOtherParams()
    self:assertEquals(nil, userboxr{}.infoOtherParams)
    self:assertEquals('font-family:serif', userboxr{['info-other-param'] = 'font-family:serif'}.infoOtherParams)
    self:assertEquals('font-family:times', userboxr{['info-op'] = 'font-family:times'}.infoOtherParams)
end

--------------------------------------------------------------------------------
-- Userboxr id2 tests
--------------------------------------------------------------------------------

function suite:testUserboxrId2()
    self:assertEquals('id', userboxr{}.id2)
    self:assertEquals('Id text.', userboxr{logo = 'Id text.'}.id2)
    self:assertEquals('More id text.', userboxr{[3] = 'More id text.'}.id2)
    self:assertEquals('Even more id text.', userboxr{id = 'Even more id text.'}.id2)
end


function suite:testUserboxrShowId()
    self:assertEquals(true, userboxr{}.showId2)
end

function suite:testUserboxrId2Width()
    self:assertEquals('45px', userboxr{}.id2Width)
    self:assertEquals('50px', userboxr{['logo-width'] = '50'}.id2Width)
    self:assertEquals('55px', userboxr{['id-w'] = '55'}.id2Width)
end

function suite:testUserboxrId2Height()
    self:assertEquals('45px', userboxr{}.id2Height)
    self:assertEquals('50px', userboxr{['logo-height'] = '50'}.id2Height)
    self:assertEquals('55px', userboxr{['id-h'] = '55'}.id2Height)
end

function suite:testUserboxrId2BackgroundColor()
    self:assertEquals('#ddd', userboxr{}.id2BackgroundColor)
    self:assertEquals('red', userboxr{['logo-background'] = 'red'}.id2BackgroundColor)
    self:assertEquals('yellow', userboxr{[1] = 'yellow'}.id2BackgroundColor)
    self:assertEquals('blue', userboxr{['id-c'] = 'blue'}.id2BackgroundColor)
end

function suite:testUserboxrId2TextAlign()
    self:assertEquals('center', userboxr{}.id2TextAlign)
    self:assertEquals('right', userboxr{['id-a'] = 'right'}.id2TextAlign)
end

function suite:testUserboxrId2FontSize()
    self:assertEquals('14pt', userboxr{}.id2FontSize)
    self:assertEquals('16pt', userboxr{['logo-size'] = '16'}.id2FontSize)
    self:assertEquals('18pt', userboxr{[5] = '18'}.id2FontSize)
    self:assertEquals('20pt', userboxr{['id-s'] = '20'}.id2FontSize)
end

function suite:testUserboxrId2Color()
    self:assertEquals('black', userboxr{}.id2Color)
    self:assertEquals('red', userboxr{['logo-color'] = 'red'}.id2Color)
    self:assertEquals('blue', userboxr{['id-fc'] = 'blue'}.id2Color)
end

function suite:testUserboxrId2Padding()
    self:assertEquals('0 0 0 1px', userboxr{}.id2Padding)
    self:assertEquals('1px 1px 1px 1px', userboxr{['logo-padding'] = '1px 1px 1px 1px'}.id2Padding)
    self:assertEquals('2px 2px 2px 2px', userboxr{['id-p'] = '2px 2px 2px 2px'}.id2Padding)
end

function suite:testUserboxrId2LineHeight()
    self:assertEquals('1.25em', userboxr{}.id2LineHeight)
    self:assertEquals('1.5em', userboxr{['logo-line-height'] = '1.5em'}.id2LineHeight)
    self:assertEquals('1.75em', userboxr{['id-lh'] = '1.75em'}.id2LineHeight)
end

function suite:testUserboxrId2OtherParams()
    self:assertEquals(nil, userboxr{}.id2OtherParams)
    self:assertEquals('font-family:serif', userboxr{['logo-other-param'] = 'font-family:serif'}.id2OtherParams)
    self:assertEquals('font-family:times', userboxr{['id-op'] = 'font-family:times'}.id2OtherParams)
end

--------------------------------------------------------------------------------
-- Categories tests
--------------------------------------------------------------------------------

local function mainspaceCats(args)
	return categories(args, 'Foo')
end

local function templateCats(args)
	return categories(args, 'Template:Edit protected')
end

local function userCats(args)
	return categories(args, 'User:Example')
end

local function templateSubpageCats(args)
	return categories(args, 'Template:Edit protected/sandbox')
end

local function userSubpageCats(args)
	return categories(args, 'User:Example/Lipsum')
end

local userBasepage = 'Example'
local templateBasepage = 'Edit protected'

function suite:testUserCategories()
	self:assertEquals('[[Category:Foobar]]', userCats{usercategory = 'Foobar'})
	self:assertEquals('[[Category:Foobar2]]', userCats{usercategory2 = 'Foobar2'})
	self:assertEquals('[[Category:Foobar3]]', userCats{usercategory3 = 'Foobar3'})
end

function suite:testTemplateCategories()
	self:assertEquals('[[Category:Foobar| ' .. templateBasepage .. ']]', templateCats{usercategory = 'Foobar'})
	self:assertEquals('[[Category:Foobar2| ' .. templateBasepage .. ']]', templateCats{usercategory2 = 'Foobar2'})
	self:assertEquals('[[Category:Foobar3| ' .. templateBasepage .. ']]', templateCats{usercategory3 = 'Foobar3'})
end

function suite:testMultipleUserCategories()
	self:assertEquals(
		'[[Category:Foobar]][[Category:Foobar2]][[Category:Foobar3]]',
		userCats{usercategory = 'Foobar', usercategory2 = 'Foobar2', usercategory3 = 'Foobar3'}
	)
end

function suite:testMultipleTemplateCategories()
	self:assertEquals(
		'[[Category:Foobar| ' .. templateBasepage .. ']]'
			.. '[[Category:Foobar2| ' .. templateBasepage .. ']]'
			.. '[[Category:Foobar3| ' .. templateBasepage .. ']]',
		templateCats{usercategory = 'Foobar', usercategory2 = 'Foobar2', usercategory3 = 'Foobar3'}
	)
end

function suite:testNocat()
	self:assertEquals(nil, userCats{nocat = 'true', usercategory = 'Foobar'})
	self:assertEquals(nil, templateCats{nocat = 'true', usercategory = 'Foobar'})
end

function suite:testNoCategories()
	self:assertEquals('', userCats{})
	self:assertEquals('', templateCats{})
end

function suite:testUserCategorySubpages()
	self:assertEquals('[[Category:Foobar]]', userSubpageCats{usercategory = 'Foobar'})
	self:assertEquals('[[Category:Foobar]]', userCats{usercategory = 'Foobar'})
end

function suite:testTemplateCategorySubpages()
	self:assertEquals('[[Category:Foobar| ' .. templateBasepage .. ']]', templateSubpageCats{usercategory = 'Foobar'})
	self:assertEquals('[[Category:Foobar| ' .. templateBasepage .. ']]', templateCats{usercategory = 'Foobar'})
end

function suite:testUserCategoryNoSubpages()
	self:assertEquals(nil, userSubpageCats{usercategory = 'Foobar', notcatsubpages = 'yes'})
	self:assertEquals('[[Category:Foobar]]', userCats{usercategory = 'Foobar', notcatsubpages = 'yes'})
end

function suite:testTemplateCategoryNoSubpages()
	self:assertEquals(nil, templateSubpageCats{usercategory = 'Foobar', notcatsubpages = 'yes'})
	self:assertEquals('[[Category:Foobar| ' .. templateBasepage .. ']]', templateCats{usercategory = 'Foobar', notcatsubpages = 'yes'})
end

function suite:assertHasContrastCat(args, title, yes)
	local oldTitle = mw.title.getCurrentTitle
	mw.title.getCurrentTitle = function() return mw.title.new(title) end
	local data = userbox(args)
	local output = render(data)
	mw.title.getCurrentTitle = oldTitle
	if yes then
		self:assertStringContains("[[Category:Userboxes with insufficient color contrast]]", output, true)
	else
		self:assertNotStringContains("[[Category:Userboxes with insufficient color contrast]]", output, true)
	end
end
function suite:testInfoContrastTemplate()
	self:assertHasContrastCat({info = 'info', ['info-color'] = '#000000', ['info-background'] = '#000001'}, "Template:Foo", true)
	self:assertHasContrastCat({info = 'info', ['info-color'] = '#000000', ['info-background'] = '#FFFFFF'}, "Template:Foo", false)
end

function suite:testInfoContrastUser()
	self:assertHasContrastCat({info = 'info', ['info-color'] = '#000000', ['info-background'] = '#000001'}, "User:Foo", false)
	self:assertHasContrastCat({info = 'info', ['info-color'] = '#000000', ['info-background'] = '#FFFFFF'}, "User:Foo", false)
end

function suite:testInfoContrastUserSubpage()
	self:assertHasContrastCat({info = 'info', ['info-color'] = '#000000', ['info-background'] = '#000001'}, "User:Foo/bar", true)
	self:assertHasContrastCat({info = 'info', ['info-color'] = '#000000', ['info-background'] = '#FFFFFF'}, "User:Foo/bar", false)
end

function suite:testIdContrastTemplate()
	self:assertHasContrastCat({info = 'info', logo = 'id', ['logo-color'] = '#000000', ['logo-background'] = '#000001'}, "Template:Foo", true)
	self:assertHasContrastCat({info = 'info', logo = 'id', ['logo-color'] = '#000000', ['logo-background'] = '#FFFFFF'}, "Template:Foo", false)
end

function suite:testIdContrastUser()
	self:assertHasContrastCat({info = 'info', logo = 'id', ['logo-color'] = '#000000', ['logo-background'] = '#000001'}, "User:Foo", false)
	self:assertHasContrastCat({info = 'info', logo = 'id', ['logo-color'] = '#000000', ['logo-background'] = '#FFFFFF'}, "User:Foo", false)
end

function suite:testIdContrastUserSubpage()
	self:assertHasContrastCat({info = 'info', logo = 'id', ['logo-color'] = '#000000', ['logo-background'] = '#000001'}, "User:Foo/bar", true)
	self:assertHasContrastCat({info = 'info', logo = 'id', ['logo-color'] = '#000000', ['logo-background'] = '#FFFFFF'}, "User:Foo/bar", false)
end

function suite:testMainspaceCategory()
	self:assertEquals('[[Category:Pages with templates in the wrong namespace]]', mainspaceCats{info = 'info'})
end

return suite
Retrieved from "https://kenshi.wiki/index.php?title=Module:Userbox/testcases&oldid=14677"