Module:Userbox/testcases

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

 localuserbox=ubx['_userbox']
 localuserbox2=ubx['_userbox-2']
 localuserboxr=ubx['_userbox-r']
 localrender=ubx.render
 localcategories=ubx.categories

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

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

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

 localfunctioninTagAttr(s,tag,attr)
 -- Makes a pattern that tests whether s is inside a given html tag
 -- and a given html attribute.
 returninTag(inAttr(s,attr),tag)
 end

 localfunctionrenderId(data)
 data.showId=true
 returnrender(data)
 end

 localfunctionrenderId2(data)
 data.showId2=true
 returnrender(data)
 end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 functionsuite: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

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

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

 functionsuite: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
 --------------------------------------------------------------------------------

 functionsuite: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

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

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

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

 functionsuite: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

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

 functionsuite: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

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

 functionsuite: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

 functionsuite: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

 functionsuite: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

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

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

 functionsuite: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

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

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

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

 functionsuite: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

 functionsuite: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

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

 functionsuite: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

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

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

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

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


 functionsuite: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


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

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

 functionsuite: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
 --------------------------------------------------------------------------------

 functionsuite: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
 functionsuite:testUserbox2ShowId()
 self:assertEquals(true,userbox2{}.showId)
 end

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

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

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

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

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

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

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

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

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

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

 functionsuite: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

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

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

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

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

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

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

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

 functionsuite: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

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

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

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

 functionsuite: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

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

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

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

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

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

 functionsuite: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
 --------------------------------------------------------------------------------

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

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

 functionsuite: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


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

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

 functionsuite: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
 --------------------------------------------------------------------------------

 functionsuite: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
 functionsuite:testUserboxrInfoTextAlign()
 self:assertEquals('left',userboxr{}.infoTextAlign)
 self:assertEquals('right',userboxr{['info-align']='right'}.infoTextAlign)
 self:assertEquals('center',userboxr{['info-a']='center'}.infoTextAlign)
 end

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


 functionsuite: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

 functionsuite: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


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

 functionsuite: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
 --------------------------------------------------------------------------------

 functionsuite: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


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

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

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

 functionsuite: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

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

 functionsuite: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

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

 functionsuite: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

 functionsuite: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

 functionsuite: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
 --------------------------------------------------------------------------------

 localfunctionmainspaceCats(args)
 returncategories(args,'Foo')
 end

 localfunctiontemplateCats(args)
 returncategories(args,'Template:Edit protected')
 end

 localfunctionuserCats(args)
 returncategories(args,'User:Example')
 end

 localfunctiontemplateSubpageCats(args)
 returncategories(args,'Template:Edit protected/sandbox')
 end

 localfunctionuserSubpageCats(args)
 returncategories(args,'User:Example/Lipsum')
 end

 localuserBasepage='Example'
 localtemplateBasepage='Edit protected'

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

 functionsuite: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

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

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

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

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

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

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

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

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

 functionsuite:assertHasContrastCat(args,title,yes)
 localoldTitle=mw.title.getCurrentTitle
 mw.title.getCurrentTitle=function()returnmw.title.new(title)end
 localdata=userbox(args)
 localoutput=render(data)
 mw.title.getCurrentTitle=oldTitle
 ifyesthen
 self:assertStringContains("[[Category:Userboxes with insufficient color contrast]]",output,true)
 else
 self:assertNotStringContains("[[Category:Userboxes with insufficient color contrast]]",output,true)
 end
 end
 functionsuite: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

 functionsuite: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

 functionsuite: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

 functionsuite: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

 functionsuite: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

 functionsuite: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

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

 returnsuite