Module:Documentation/testcases

This is the test cases page for the module Module:Documentation. Results of the test cases.
 -- Test cases page for [[Module:Documentation]]. See talk page to run tests.

 localdoc=require('Module:Documentation/sandbox')
 localScribuntoUnit=require('Module:ScribuntoUnit')
 localsuite=ScribuntoUnit:new()

 --------------------------------------------------------------------------------------------
 -- Test case helper functions
 --------------------------------------------------------------------------------------------

 localfunctiongetEnv(page)
 -- Gets an env table using the specified page.
 returndoc.getEnvironment{page=page}
 end

 --------------------------------------------------------------------------------------------
 -- Test helper functions
 --------------------------------------------------------------------------------------------

 functionsuite:testMessage()
 self:assertEquals('sandbox',doc.message('sandbox-subpage'))
 self:assertEquals('Subpages of this foobar',doc.message('subpages-link-display',{'foobar'}))
 self:assertEquals(true,doc.message('display-strange-usage-category',nil,'boolean'))
 end

 functionsuite:testMakeToolbar()
 self:assertEquals(nil,doc.makeToolbar())
 self:assertEquals('<span class="documentation-toolbar">(Foo)</span>',doc.makeToolbar('Foo'))
 self:assertEquals('<span class="documentation-toolbar">(Foo &#124; Bar)</span>',doc.makeToolbar('Foo','Bar'))
 end

 functionsuite:testMakeWikilink()
 self:assertEquals('[[Foo]]',doc.makeWikilink('Foo'))
 self:assertEquals('[[Foo|Bar]]',doc.makeWikilink('Foo','Bar'))
 end

 functionsuite:testMakeCategoryLink()
 self:assertEquals('[[Category:Foo]]',doc.makeCategoryLink('Foo'))
 self:assertEquals('[[Category:Foo|Bar]]',doc.makeCategoryLink('Foo','Bar'))
 end

 functionsuite:testMakeUrlLink()
 self:assertEquals('[Foo Bar]',doc.makeUrlLink('Foo','Bar'))
 end

 --------------------------------------------------------------------------------------------
 -- Test env table
 --------------------------------------------------------------------------------------------

 functionsuite:assertEnvFieldEquals(expected,page,field)
 localenv=getEnv(page)
 self:assertEquals(expected,env[field])
 end

 functionsuite:assertEnvTitleEquals(expected,page,titleField)
 localenv=getEnv(page)
 localtitle=env[titleField]
 self:assertEquals(expected,title.prefixedText)
 end

 functionsuite:testEnvTitle()
 self:assertEnvTitleEquals('Wikipedia:Sandbox','Wikipedia:Sandbox','title')
 self:assertEnvTitleEquals('Template:Example/sandbox','Template:Example/sandbox','title')
 end

 functionsuite:testEnvBadTitle()
 localenv=doc.getEnvironment{page='Bad[]Title'}
 localtitle=env.title
 self:assertEquals(nil,title)
 end

 functionsuite:testEnvTemplateTitle()
 self:assertEnvTitleEquals('Template:Example','Template:Example','templateTitle')
 self:assertEnvTitleEquals('Template:Example','Template talk:Example','templateTitle')
 self:assertEnvTitleEquals('Template:Example','Template:Example/sandbox','templateTitle')
 self:assertEnvTitleEquals('Template:Example','Template talk:Example/sandbox','templateTitle')
 self:assertEnvTitleEquals('Template:Example','Template:Example/testcases','templateTitle')
 self:assertEnvTitleEquals('Template:Example/foo','Template:Example/foo','templateTitle')
 self:assertEnvTitleEquals('File:Example','File talk:Example','templateTitle')
 self:assertEnvTitleEquals('File:Example','File talk:Example/sandbox','templateTitle')
 end

 functionsuite:testEnvDocTitle()
 self:assertEnvTitleEquals('Template:Example/doc','Template:Example','docTitle')
 self:assertEnvTitleEquals('Template:Example/doc','Template talk:Example','docTitle')
 self:assertEnvTitleEquals('Template:Example/doc','Template:Example/sandbox','docTitle')
 self:assertEnvTitleEquals('Talk:Example/doc','Example','docTitle')
 self:assertEnvTitleEquals('File talk:Example.png/doc','File:Example.png','docTitle')
 self:assertEnvTitleEquals('File talk:Example.png/doc','File talk:Example.png/sandbox','docTitle')
 end

 functionsuite:testEnvSandboxTitle()
 self:assertEnvTitleEquals('Template:Example/sandbox','Template:Example','sandboxTitle')
 self:assertEnvTitleEquals('Template:Example/sandbox','Template talk:Example','sandboxTitle')
 self:assertEnvTitleEquals('Template:Example/sandbox','Template:Example/sandbox','sandboxTitle')
 self:assertEnvTitleEquals('Talk:Example/sandbox','Example','sandboxTitle')
 self:assertEnvTitleEquals('File talk:Example.png/sandbox','File:Example.png','sandboxTitle')
 end

 functionsuite:testEnvTestcasesTitle()
 self:assertEnvTitleEquals('Template:Example/testcases','Template:Example','testcasesTitle')
 self:assertEnvTitleEquals('Template:Example/testcases','Template talk:Example','testcasesTitle')
 self:assertEnvTitleEquals('Template:Example/testcases','Template:Example/testcases','testcasesTitle')
 self:assertEnvTitleEquals('Talk:Example/testcases','Example','testcasesTitle')
 self:assertEnvTitleEquals('File talk:Example.png/testcases','File:Example.png','testcasesTitle')
 end

 functionsuite:testEnvProtectionLevels()
 localpipeEnv=getEnv('Template:?')
 self:assertEquals('autoconfirmed',pipeEnv.protectionLevels.edit[1])
 localsandboxEnv=getEnv('Wikipedia:Sandbox')
 localsandboxEditLevels=sandboxEnv.protectionLevels.edit
 ifsandboxEditLevelsthen-- sandboxEditLevels may also be nil if the page is unprotected
 self:assertEquals(nil,sandboxEditLevels[1])
 else
 self:assertEquals(nil,sandboxEditLevels)
 end
 end

 functionsuite:testEnvSubjectSpace()
 self:assertEnvFieldEquals(10,'Template:Sandbox','subjectSpace')
 self:assertEnvFieldEquals(10,'Template talk:Sandbox','subjectSpace')
 self:assertEnvFieldEquals(0,'Foo','subjectSpace')
 self:assertEnvFieldEquals(0,'Talk:Foo','subjectSpace')
 end

 functionsuite:testEnvDocSpace()
 self:assertEnvFieldEquals(10,'Template:Sandbox','docSpace')
 self:assertEnvFieldEquals(828,'Module:Sandbox','docSpace')
 self:assertEnvFieldEquals(1,'Foo','docSpace')
 self:assertEnvFieldEquals(7,'File:Example.png','docSpace')
 self:assertEnvFieldEquals(9,'MediaWiki:Watchlist-details','docSpace')
 self:assertEnvFieldEquals(15,'Category:Wikipedians','docSpace')
 end

 functionsuite:testEnvDocpageBase()
 self:assertEnvFieldEquals('Template:Example','Template:Example','docpageBase')
 self:assertEnvFieldEquals('Template:Example','Template:Example/sandbox','docpageBase')
 self:assertEnvFieldEquals('Template:Example','Template talk:Example','docpageBase')
 self:assertEnvFieldEquals('File talk:Example.png','File:Example.png','docpageBase')
 self:assertEnvFieldEquals('File talk:Example.png','File talk:Example.png','docpageBase')
 self:assertEnvFieldEquals('File talk:Example.png','File talk:Example.png/sandbox','docpageBase')
 end

 functionsuite:testEnvCompareUrl()
 -- We use "Template:Edit protected" rather than "Template:Example" here as it has a space in the title.
 localexpected='https://en.wikipedia.org/w/index.php?title=Special%3AComparePages&page1=Template%3AEdit+protected&page2=Template%3AEdit+protected%2Fsandbox'
 self:assertEnvFieldEquals(expected,'Template:Edit protected','compareUrl')
 self:assertEnvFieldEquals(expected,'Template:Edit protected/sandbox','compareUrl')
 self:assertEnvFieldEquals(nil,'Template:Non-existent template adsfasdg','compareUrl')
 self:assertEnvFieldEquals(nil,'Template:Fact','compareUrl')-- Exists but doesn't have a sandbox.
 end

 --------------------------------------------------------------------------------------------
 -- Test sandbox notice
 --------------------------------------------------------------------------------------------

 functionsuite.getSandboxNoticeTestData(page)
 localenv=getEnv(page)
 localtemplatePage=page:match('^(.*)/sandbox$')
 localimage='[[File:Sandbox.svg|50px|alt=|link=]]'
 localtemplateBlurb='This is the [[Wikipedia:Template test cases|template sandbox]] page for [['..templatePage..']]'
 localmoduleBlurb='This is the [[Wikipedia:Template test cases|module sandbox]] page for [['..templatePage..']]'
 localotherBlurb='This is the sandbox page for [['..templatePage..']]'
 localdiff='[https://en.wikipedia.org/w/index.php?title=Special%3AComparePages&page1='..mw.uri.encode(templatePage)..'&page2='..mw.uri.encode(page)..' diff]'
 localtestcasesBlurb='See also the companion subpage for [['..templatePage..'/testcases|test cases]].'
 localcategory='[[Category:Template sandboxes]]'
 localclear='<div class="documentation-clear"></div>'
 returnenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category,clear
 end

 functionsuite:testSandboxNoticeNotSandbox()
 localenv=getEnv('Template:Example')
 localnotice=doc.sandboxNotice({},env)
 self:assertEquals(nil,notice)
 end

 functionsuite:testSandboxNoticeStaticVals()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category,clear=suite.getSandboxNoticeTestData('Template:Example/sandbox')
 localnotice=doc.sandboxNotice({},env)

 -- Escape metacharacters (mainly '-')
 clear=clear:gsub('%p','%%%0')

 self:assertStringContains('^'..clear,notice,false)
 self:assertStringContains(image,notice,true)
 self:assertStringContains(category,notice,true)
 end

 functionsuite:testSandboxNoticeTemplateBlurb()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category=suite.getSandboxNoticeTestData('Template:Example/sandbox')
 localnotice=doc.sandboxNotice({},env)
 self:assertStringContains(templateBlurb,notice,true)
 end

 functionsuite:testSandboxNoticeModuleBlurb()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category=suite.getSandboxNoticeTestData('Module:Math/sandbox')
 localnotice=doc.sandboxNotice({},env)
 self:assertStringContains(moduleBlurb,notice,true)
 end

 functionsuite:testSandboxNoticeOtherBlurb()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category=suite.getSandboxNoticeTestData('User:Mr. Stradivarius/sandbox')
 localnotice=doc.sandboxNotice({},env)
 self:assertStringContains(otherBlurb,notice,true)
 end

 functionsuite:testSandboxNoticeBlurbDiff()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category=suite.getSandboxNoticeTestData('Template:Example/sandbox')
 localnotice=doc.sandboxNotice({},env)
 ifmw.title.getCurrentTitle().isTalkthen
 -- This test doesn't work in the debug console due to the use of frame:preprocess({{REVISIONID}}).
 -- The frame test doesn't seem to be working for now, so adding a namespace hack.
 self:assertStringContains(diff,notice,true)
 end
 end

 functionsuite:testSandboxNoticeBlurbDiffNoBasePage()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category=suite.getSandboxNoticeTestData('Module:User:Mr. Stradivarius/sandbox')
 localnotice=doc.sandboxNotice({},env)
 ifmw.title.getCurrentTitle().isTalkthen
 -- This test doesn't work in the debug console due to the use of frame:preprocess({{REVISIONID}}).
 -- The frame test doesn't seem to be working for now, so adding a namespace hack.
 self:assertNotStringContains(diff,notice,true)
 end
 end

 functionsuite:testSandboxNoticeTestcases()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category=suite.getSandboxNoticeTestData('Template:Edit protected/sandbox')
 localnotice=doc.sandboxNotice({},env)
 self:assertStringContains(testcasesBlurb,notice,true)
 end

 functionsuite:testSandboxNoticeNoTestcases()
 localenv,image,templateBlurb,moduleBlurb,otherBlurb,diff,testcasesBlurb,category=suite.getSandboxNoticeTestData('Template:Example/sandbox')
 localnotice=doc.sandboxNotice({},env)
 self:assertNotStringContains(testcasesBlurb,notice,true)
 end

 --------------------------------------------------------------------------------------------
 -- Test protection template
 -- 
 -- There's not much we can do with this until {{pp-meta}} gets rewritten in Lua. At the
 -- moment the protection detection only works for the current page, and the testcases pages
 -- will be unprotected.
 --------------------------------------------------------------------------------------------

 functionsuite:testProtectionTemplateUnprotectedTemplate()
 localenv=getEnv('Template:Example')
 self:assertEquals(nil,doc.protectionTemplate(env))
 end

 functionsuite:testProtectionTemplateProtectedTemplate()
 localenv=getEnv('Template:Navbox')
 -- Test whether there is some content. We don't care what the content is, as the protection level
 -- detected will be for the current page, not the template.
 self:assertTrue(doc.protectionTemplate(env))
 end

 functionsuite:testProtectionTemplateUnprotectedModule()
 localenv=getEnv('Module:Example')
 self:assertEquals(nil,doc.protectionTemplate(env))
 end

 functionsuite:testProtectionTemplateProtectedModule()
 localenv=getEnv('Module:Yesno')
 -- Test whether there is some content. We don't care what the content is, as the protection level
 -- detected will be for the current page, not the template.
 self:assertTrue(doc.protectionTemplate(env))
 end

 --------------------------------------------------------------------------------------------
 -- Test _startBox
 --------------------------------------------------------------------------------------------

 functionsuite:testStartBoxContentArg()
 localpattern='<div class="documentation%-startbox">\n<span class="documentation%-heading" id="documentation%-heading">.-</span></div>'
 localstartBox=doc._startBox({content='some documentation'},getEnv('Template:Example'))
 self:assertStringContains(pattern,startBox)
 end

 functionsuite:testStartBoxHtml()
 self:assertStringContains(
 '<div class="documentation%-startbox">\n<span class="documentation%-heading" id="documentation%-heading">.-</span><span class="mw%-editsection%-like plainlinks">.-</span></div>',
 doc._startBox({},getEnv('Template:Example'))
 )
 end

 --------------------------------------------------------------------------------------------
 -- Test makeStartBoxLinksData
 --------------------------------------------------------------------------------------------

 functionsuite:testMakeStartBoxLinksData()
 localenv=getEnv('Template:Example')
 localdata=doc.makeStartBoxLinksData({},env)
 self:assertEquals('Template:Example',data.title.prefixedText)
 self:assertEquals('Template:Example/doc',data.docTitle.prefixedText)
 self:assertEquals('view',data.viewLinkDisplay)
 self:assertEquals('edit',data.editLinkDisplay)
 self:assertEquals('history',data.historyLinkDisplay)
 self:assertEquals('purge',data.purgeLinkDisplay)
 self:assertEquals('create',data.createLinkDisplay)
 end

 functionsuite:testMakeStartBoxLinksDataTemplatePreload()
 localenv=getEnv('Template:Example')
 localdata=doc.makeStartBoxLinksData({},env)
 self:assertEquals('Template:Documentation/preload',data.preload)
 end

 functionsuite:testMakeStartBoxLinksDataArgsPreload()
 localenv=getEnv('Template:Example')
 localdata=doc.makeStartBoxLinksData({preload='My custom preload'},env)
 self:assertEquals('My custom preload',data.preload)
 end

 --------------------------------------------------------------------------------------------
 -- Test renderStartBoxLinks
 --------------------------------------------------------------------------------------------

 functionsuite.makeExampleStartBoxLinksData(exists)
 -- Makes a data table to be used with testRenderStartBoxLinksExists and testRenderStartBoxLinksDoesntExist.
 localdata={}
 ifexiststhen
 data.title=mw.title.new('Template:Example')
 data.docTitle=mw.title.new('Template:Example/doc')
 else
 data.title=mw.title.new('Template:NonExistentTemplate')
 data.docTitle=mw.title.new('Template:NonExistentTemplate/doc')
 end
 data.viewLinkDisplay='view'
 data.editLinkDisplay='edit'
 data.historyLinkDisplay='history'
 data.purgeLinkDisplay='purge'
 data.createLinkDisplay='create'
 data.preload='Template:MyPreload'
 returndata
 end

 functionsuite:testRenderStartBoxLinksExists()
 localdata=suite.makeExampleStartBoxLinksData(true)
 localexpected='&#91;[[Template:Example/doc|view]]&#93; &#91;[[Special:EditPage/Template:Example/doc|edit]]&#93; &#91;[[Special:PageHistory/Template:Example/doc|history]]&#93; &#91;[[Special:Purge/Template:Example|purge]]&#93;'
 self:assertEquals(expected,doc.renderStartBoxLinks(data))
 end

 functionsuite:testRenderStartBoxLinksDoesntExist()
 localdata=suite.makeExampleStartBoxLinksData(false)
 localexpected='&#91;[https://en.wikipedia.org/w/index.php?title=Template:NonExistentTemplate/doc&action=edit&preload=Template%3AMyPreload create]&#93; &#91;[[Special:Purge/Template:NonExistentTemplate|purge]]&#93;'
 self:assertEquals(expected,doc.renderStartBoxLinks(data))
 end

 --------------------------------------------------------------------------------------------
 -- Test makeStartBoxData
 --------------------------------------------------------------------------------------------

 functionsuite:testStartBoxDataBlankHeading()
 localdata=doc.makeStartBoxData({heading=''},{})
 self:assertEquals(nil,data)
 end

 functionsuite:testStartBoxDataHeadingTemplate()
 localenv=getEnv('Template:Example')
 localdata=doc.makeStartBoxData({},env)
 localexpected='[[File:Test Template Info-Icon - Version (2).svg|50px|link=|alt=]] Template documentation'
 self:assertEquals(expected,data.heading)
 end

 functionsuite:testStartBoxDataHeadingModule()
 localenv=getEnv('Module:Example')
 localdata=doc.makeStartBoxData({},env)
 localexpected='[[File:Test Template Info-Icon - Version (2).svg|50px|link=|alt=]] Module documentation'
 self:assertEquals(expected,data.heading)
 end

 functionsuite:testStartBoxDataHeadingFile()
 localenv=getEnv('File:Example.png')
 localdata=doc.makeStartBoxData({},env)
 localexpected='Summary'
 self:assertEquals(expected,data.heading)
 end

 functionsuite:testStartBoxDataHeadingOther()
 localenv=getEnv('User:Example')
 localdata=doc.makeStartBoxData({},env)
 localexpected='Documentation'
 self:assertEquals(expected,data.heading)
 end

 functionsuite:testStartBoxDataHeadingStyle()
 localdata=doc.makeStartBoxData({['heading-style']='foo:bar'},{})
 self:assertEquals('foo:bar',data.headingStyleText)
 end

 functionsuite:testStartBoxDataHeadingStyleTemplate()
 localenv=getEnv('Template:Example')
 localdata=doc.makeStartBoxData({},env)
 self:assertEquals(nil,data.headingStyleText)
 end

 functionsuite:testStartBoxDataHeadingStyleOther()
 localenv=getEnv('User:Example')
 localdata=doc.makeStartBoxData({},env)
 self:assertEquals(nil,data.headingStyleText)
 end

 functionsuite:testStartBoxDataLinks()
 localenv=getEnv('Template:Example')
 localdata=doc.makeStartBoxData({},env,'some links')
 self:assertEquals('some links',data.links)
 self:assertEquals('mw-editsection-like plainlinks',data.linksClass)
 end

 functionsuite:testStartBoxDataNoLinks()
 localenv=getEnv('Template:Example')
 localdata=doc.makeStartBoxData({},env)
 self:assertEquals(nil,data.links)
 self:assertEquals(nil,data.linksClass)
 self:assertEquals(nil,data.linksId)
 end

 --------------------------------------------------------------------------------------------
 -- Test renderStartBox
 --------------------------------------------------------------------------------------------

 functionsuite:testRenderStartBox()
 localexpected='<div class="documentation-startbox">\n<span id="documentation-heading"></span></div>'
 self:assertEquals(expected,doc.renderStartBox{})
 end

 functionsuite:testRenderStartBoxHeadingStyleText()
 self:assertStringContains('\n<span id="documentation-heading" style="foo:bar">',doc.renderStartBox{headingStyleText='foo:bar'},true)
 end

 functionsuite:testRenderStartBoxHeading()
 self:assertStringContains('\n<span id="documentation-heading">Foobar</span>',doc.renderStartBox{heading='Foobar'},true)
 end

 functionsuite:testRenderStartBoxLinks()
 self:assertStringContains('<span>list of links</span>',doc.renderStartBox{links='list of links'},true)
 end

 functionsuite:testRenderStartBoxLinksClass()
 self:assertStringContains('<span class="linksclass">list of links</span>',doc.renderStartBox{linksClass='linksclass',links='list of links'},true)
 self:assertNotStringContains('linksclass',doc.renderStartBox{linksClass='linksclass'},true)
 end

 functionsuite:testRenderStartBoxLinksId()
 self:assertStringContains('<span id="linksid">list of links</span>',doc.renderStartBox{linksId='linksid',links='list of links'},true)
 self:assertNotStringContains('linksid',doc.renderStartBox{linksId='linksid'},true)
 end

 --------------------------------------------------------------------------------------------
 -- Test _content
 --------------------------------------------------------------------------------------------

 functionsuite:testContentArg()
 self:assertEquals('\nsome documentation\n',doc._content({content='some documentation'},{}))
 end

 functionsuite:testContentNoContent()
 localenv=getEnv('Template:This is a non-existent template agauchvaiu')
 self:assertEquals('\n\n',doc._content({},env))
 end

 functionsuite:testContentExists()
 localenv=doc.getEnvironment{'Template:Documentation/testcases/test3'}
 localdocs=mw.getCurrentFrame():preprocess('{{Template:Documentation/testcases/test3}}')
 localexpected='\n'..docs..'\n'
 self:assertEquals(expected,doc._content({},env))
 end

 --------------------------------------------------------------------------------------------
 -- Test _endBox
 --------------------------------------------------------------------------------------------

 functionsuite:testEndBoxLinkBoxOff()
 localenv=getEnv()
 self:assertEquals(nil,doc._endBox({['link box']='off'},env))
 end

 functionsuite:testEndBoxNoDocsOtherNs()
 localenv={
 subjectSpace=4,
 docTitle={
 exists=false
 }
 }
 self:assertEquals(nil,doc._endBox({},env))
 end

 functionsuite:testEndBoxAlwaysShowNs()
 self:assertTrue(doc._endBox({},getEnv('Template:Non-existent template asdfalsdhaw')))
 self:assertTrue(doc._endBox({},getEnv('Module:Non-existent module asdhewbydcyg')))
 self:assertTrue(doc._endBox({},getEnv('User:Non-existent user ahfliwebalisyday')))
 end

 functionsuite:testEndBoxStyles()
 localenv=getEnv('Template:Example')
 localendBox=doc._endBox({},env)
 self:assertStringContains('class="documentation-metadata plainlinks"',endBox,true)
 end

 functionsuite:testEndBoxLinkBoxArg()
 localenv=getEnv()
 self:assertStringContains('Custom link box',doc._endBox({['link box']='Custom link box'},env))
 end

 functionsuite:testEndBoxExperimentBlurbValidNs()
 localexpected='Editors can experiment in this.-<br />'
 self:assertStringContains(expected,doc._endBox({},getEnv('Template:Example')))
 self:assertStringContains(expected,doc._endBox({},getEnv('Module:Example')))
 self:assertStringContains(expected,doc._endBox({},getEnv('User:Example')))
 end

 functionsuite:testEndBoxExperimentBlurbInvalidNs()
 localexpected='Editors can experiment in this.-<br />'
 self:assertNotStringContains(expected,doc._endBox({},getEnv('Wikipedia:Twinkle')))-- Wikipedia:Twinkle has an existing /doc subpage
 end

 functionsuite:testEndBoxCategoriesBlurb()
 localexpected='Add categories to the %[%[.-|/doc%]%] subpage%.'
 self:assertStringContains(expected,doc._endBox({},getEnv('Template:Example')))
 self:assertStringContains(expected,doc._endBox({},getEnv('Module:Example')))
 self:assertStringContains(expected,doc._endBox({},getEnv('User:Example')))
 self:assertNotStringContains(expected,doc._endBox({[1]='Foo'},getEnv('Template:Example')))
 self:assertNotStringContains(expected,doc._endBox({content='Bar'},getEnv('Template:Example')))
 self:assertNotStringContains(expected,doc._endBox({},getEnv('Wikipedia:Twinkle')))
 end

 --------------------------------------------------------------------------------------------
 -- Test makeDocPageBlurb
 --------------------------------------------------------------------------------------------

 functionsuite:testDocPageBlurbError()
 self:assertEquals(nil,doc.makeDocPageBlurb({},{}))
 end

 functionsuite:testDocPageBlurbTemplateDocExists()
 localenv=getEnv('Template:Documentation')
 localexpected='The above [[Wikipedia:Template documentation|documentation]] is [[Help:Transclusion|transcluded]] from [[Template:Documentation/doc]]. <span class="documentation-toolbar">([[Special:EditPage/Template:Documentation/doc|edit]] &#124; [[Special:PageHistory/Template:Documentation/doc|history]])</span><br />'
 self:assertEquals(expected,doc.makeDocPageBlurb({},env))
 end

 functionsuite:testDocPageBlurbTemplateDocDoesntExist()
 localenv=getEnv('Template:Non-existent template ajlkfdsa')
 self:assertEquals(nil,doc.makeDocPageBlurb({},env))
 end

 functionsuite:testDocPageBlurbModuleDocExists()
 localenv=getEnv('Module:Example')
 localexpected='The above [[Wikipedia:Template documentation|documentation]] is [[Help:Transclusion|transcluded]] from [[Module:Example/doc]]. <span class="documentation-toolbar">([[Special:EditPage/Module:Example/doc|edit]] &#124; [[Special:PageHistory/Module:Example/doc|history]])</span><br />'
 self:assertEquals(expected,doc.makeDocPageBlurb({},env))
 end

 functionsuite:testDocPageBlurbModuleDocDoesntExist()
 localenv=getEnv('Module:Non-existent module ajlkfdsa')
 localexpected='You might want to [https://en.wikipedia.org/w/index.php?title=Module:Non-existent_module_ajlkfdsa/doc&action=edit&preload=Template%3ADocumentation%2Fpreload-module-doc create] a documentation page for this [[Wikipedia:Lua|Scribunto module]].<br />'
 self:assertEquals(expected,doc.makeDocPageBlurb({},env))
 end

 --------------------------------------------------------------------------------------------
 -- Test makeExperimentBlurb
 --------------------------------------------------------------------------------------------

 functionsuite:testExperimentBlurbTemplate()
 localenv=getEnv('Template:Example')
 self:assertStringContains("Editors can experiment in this template's .- and .- pages.",doc.makeExperimentBlurb({},env),false)
 end

 functionsuite:testExperimentBlurbModule()
 localenv=getEnv('Module:Example')
 self:assertStringContains("Editors can experiment in this module's .- and .- pages.",doc.makeExperimentBlurb({},env),false)
 end

 functionsuite:testExperimentBlurbSandboxExists()
 localenv=getEnv('Template:Edit protected')
 localpattern='[[Template:Edit protected/sandbox|sandbox]] <span class="documentation-toolbar">([[Special:EditPage/Template:Edit protected/sandbox|edit]] &#124; [https://en.wikipedia.org/w/index.php?title=Special%3AComparePages&page1=Template%3AEdit+protected&page2=Template%3AEdit+protected%2Fsandbox diff])</span>'
 self:assertStringContains(pattern,doc.makeExperimentBlurb({},env),true)
 end

 functionsuite:testExperimentBlurbSandboxDoesntExist()
 localenv=getEnv('Template:Non-existent template sajdfasd')
 localpattern='sandbox <span class="documentation-toolbar">([https://en.wikipedia.org/w/index.php?title=Template:Non-existent_template_sajdfasd/sandbox&action=edit&preload=Template%3ADocumentation%2Fpreload-sandbox create] &#124; [https://en.wikipedia.org/w/index.php?title=Template:Non-existent_template_sajdfasd/sandbox&preload=Template%3ADocumentation%2Fmirror&action=edit&summary=Create+sandbox+version+of+%5B%5BTemplate%3ANon-existent+template+sajdfasd%5D%5D mirror])</span>'
 self:assertStringContains(pattern,doc.makeExperimentBlurb({},env),true)
 end

 functionsuite:testExperimentBlurbTestcasesExist()
 localenv=getEnv('Template:Edit protected')
 localpattern='[[Template:Edit protected/testcases|testcases]] <span class="documentation-toolbar">([[Special:EditPage/Template:Edit protected/testcases|edit]])</span>'
 self:assertStringContains(pattern,doc.makeExperimentBlurb({},env),true)
 end

 functionsuite:testExperimentBlurbTestcasesDontExist()
 localenv=getEnv('Template:Non-existent template sajdfasd')
 localpattern='testcases <span class="documentation-toolbar">([https://en.wikipedia.org/w/index.php?title=Template:Non-existent_template_sajdfasd/testcases&action=edit&preload=Template%3ADocumentation%2Fpreload-testcases create])</span>'
 self:assertStringContains(pattern,doc.makeExperimentBlurb({},env),true)
 end

 --------------------------------------------------------------------------------------------
 -- Test makeCategoriesBlurb
 --------------------------------------------------------------------------------------------

 functionsuite:testMakeCategoriesBlurb()
 localenv=getEnv('Template:Example')
 self:assertEquals('Add categories to the [[Template:Example/doc|/doc]] subpage.',doc.makeCategoriesBlurb({},env))
 end

 --------------------------------------------------------------------------------------------
 -- Test makeSubpagesBlurb
 --------------------------------------------------------------------------------------------

 functionsuite:testMakeSubpagesBlurbTemplate()
 localenv=getEnv('Template:Example')
 self:assertEquals('[[Special:PrefixIndex/Template:Example/|Subpages of this template]].',doc.makeSubpagesBlurb({},env))
 end

 functionsuite:testMakeSubpagesBlurbModule()
 localenv=getEnv('Module:Example')
 self:assertEquals('[[Special:PrefixIndex/Module:Example/|Subpages of this module]].',doc.makeSubpagesBlurb({},env))
 end

 functionsuite:testMakeSubpagesBlurbOther()
 localenv=getEnv('File:Example.png')
 self:assertEquals('[[Special:PrefixIndex/File:Example.png/|Subpages of this page]].',doc.makeSubpagesBlurb({},env))
 end
 --------------------------------------------------------------------------------------------
 -- Test addTrackingCategories
 --------------------------------------------------------------------------------------------

 functionsuite.getStrangeUsageCat()
 return'[[Category:Wikipedia pages with strange ((documentation)) usage]]'
 end

 functionsuite:testAddTrackingCategoriesTemplatePage()
 localenv=getEnv('Template:Example')
 self:assertEquals('',doc.addTrackingCategories(env))
 end

 functionsuite:testAddTrackingCategoriesDocPage()
 localenv=getEnv('Template:Example/doc')
 self:assertEquals(self.getStrangeUsageCat(),doc.addTrackingCategories(env))
 end

 functionsuite:testAddTrackingCategoriesTestcasesPage()
 localenv=getEnv('Template:Example/testcases')
 self:assertEquals(self.getStrangeUsageCat(),doc.addTrackingCategories(env))
 end

 functionsuite:testAddTrackingCategoriesModuleDoc()
 localenv=getEnv('Module:Math/doc')
 self:assertEquals(self.getStrangeUsageCat(),doc.addTrackingCategories(env))
 end

 functionsuite:testAddTrackingCategoriesModuleTestcases()
 localenv=getEnv('Module:Math/testcases')
 self:assertEquals('',doc.addTrackingCategories(env))
 end

 functionsuite:testAddTrackingCategoriesInvalidTitle()
 localenv=getEnv('Template:Foo[]Bar')
 self:assertEquals(nil,doc.addTrackingCategories(env))
 end

 --------------------------------------------------------------------------------------------
 -- Whitespace tests
 --------------------------------------------------------------------------------------------

 functionsuite:testNoTrailingWhitespace()
 self:assertStringContains('of this template%]%].</div></div>$',doc._main{page='Template:Example'})
 end

 returnsuite
Retrieved from "https://en.wikipedia.org/w/index.php?title=Module:Documentation/testcases&oldid=1210770399"