Module:WikitextParser/testcases

local parser = require( 'Module:WikitextParser' )
local testpage = mw.title.new( 'Module:WikitextParser/testpage' ):getContent()
local ScribuntoUnit = require( 'Module:ScribuntoUnit' )
local Suite = ScribuntoUnit:new()

function Suite:testLead()
	self:assertEquals( '', parser.getLead( '' ) )
	self:assertEquals( '', parser.getLead( '==b==' ) )
	self:assertEquals( 'a', parser.getLead( 'a' ) )
	self:assertEquals( 'a', parser.getLead( 'a', 'a\n==b==' ) )
	self:assertEquals( 'This test page interacts with [[Module:WikitextParser/testcases]].', parser.getLead( testpage ) )
end

function Suite:testSection()
	self:assertEquals( nil, parser.getSection( 'a', 'a' ) )
	self:assertEquals( '', parser.getSection( '==a==', 'a' ) )
	self:assertEquals( 'b', parser.getSection( '==a==\nb', 'a' ) )
	self:assertEquals( 'b', parser.getSection( '==a==\nb\n==c==\nd', 'a' ) )
	self:assertEquals( 'b', parser.getSection( '==a==\nb\n==a==\nd', 'a' ) )
	self:assertEquals( 'b\n===c===\nd', parser.getSection( '==a==\nb\n===c===\nd', 'a' ) )
	self:assertEquals( 'd', parser.getSection( '==a==\nb\n===c===\nd', 'c' ) )
	self:assertEquals( 'a\n===Subsection===\nb', parser.getSection( testpage, 'Section' ) )
	self:assertEquals( 'b', parser.getSection( testpage, 'Subsection' ) )
end

function Suite:testSectionTag()
	self:assertEquals( nil, parser.getSectionTag( 'a', 'a' ) )
	self:assertEquals( nil, parser.getSectionTag( 'a<section begin="b" /><section end="b" />c', 'a' ) )
	self:assertEquals( '', parser.getSectionTag( 'a<section begin="b" /><section end="b" />c', 'b' ) )
	self:assertEquals( 'c', parser.getSectionTag( 'a<section begin="b" />c<section end="b" />d', 'b' ) )
	self:assertEquals( '', parser.getSectionTag( testpage, 'a' ) )
	self:assertEquals( 'b', parser.getSectionTag( testpage, 'b' ) )
	self:assertEquals( '{|\n!c\n|}', parser.getSectionTag( testpage, 'c' ) )
	self:assertEquals( nil, parser.getSectionTag( testpage, 'd' ) )
end

function Suite:testSections()
	self:assertDeepEquals( {}, parser.getSections( '' ) )
	self:assertDeepEquals( {}, parser.getSections( 'a' ) )
	self:assertDeepEquals( { ['a']='' }, parser.getSections( '==a==' ) )
	self:assertDeepEquals( { ['b']='' }, parser.getSections( 'a\n==b==' ) )
	self:assertDeepEquals( { ['a']='', ['b']='' }, parser.getSections( '==a==\n==b==' ) )
	self:assertDeepEquals( { ['a']='b' }, parser.getSections( '==a==\nb' ) )
	self:assertDeepEquals( { ['b']='c' }, parser.getSections( 'a\n==b==\nc' ) )
	self:assertDeepEquals( { ['b']='c', ['d']='e' }, parser.getSections( 'a\n==b==\nc\n===d===\ne' ) )
end

function Suite:testLists()
	self:assertDeepEquals( {}, parser.getLists( '' ) )
	self:assertDeepEquals( {}, parser.getLists( 'a' ) )
	self:assertDeepEquals( { '*a' }, parser.getLists( '*a' ) )
	self:assertDeepEquals( { '*a\n*b' }, parser.getLists( '*a\n*b' ) )
	self:assertDeepEquals( { '*b\n*c' }, parser.getLists( 'a\n*b\n*c\nd' ) )
	self:assertDeepEquals( { '*b\n*c', '#e\n#f' }, parser.getLists( 'a\n*b\n*c\nd\n#e\n#f\ng' ) )
	self:assertDeepEquals( {
		'*b\n*c',
		'#e\n#f',
		'*c\n*d',
		'#h\n#i',
		'*c\n*d',
		'#h\n#i',
	}, parser.getLists( testpage ) )
end

function Suite:testParagraphs()
	self:assertDeepEquals( {}, parser.getParagraphs( '' ) )
	self:assertDeepEquals( {}, parser.getParagraphs( '{{a}}' ) )
	self:assertDeepEquals( {}, parser.getParagraphs( '{{a\n|b=c}}' ) )
	self:assertDeepEquals( {}, parser.getParagraphs( '{{a}}\n{{b}}\n{{c}}' ) )
	self:assertDeepEquals( {}, parser.getParagraphs( '{{a}}\n\n{{b}}\n\n{{c}}' ) )
	self:assertDeepEquals( { 'a' }, parser.getParagraphs( 'a' ) )
	self:assertDeepEquals( { 'a{{b}}' }, parser.getParagraphs( 'a{{b}}' ) )
	self:assertDeepEquals( { '{{a}}b' }, parser.getParagraphs( '{{a}}b' ) )
	self:assertDeepEquals( { 'a' }, parser.getParagraphs( 'a\n\n{{b}}' ) )
	self:assertDeepEquals( { 'b' }, parser.getParagraphs( '{{a}}\n\nb' ) )
	self:assertDeepEquals( { '{{a}}b{{c}}' }, parser.getParagraphs( '{{a}}b{{c}}' ) )
	self:assertDeepEquals( { 'a', 'b', 'c' }, parser.getParagraphs( 'a\n\nb\n\nc' ) )
	self:assertDeepEquals( { 'a', 'c' }, parser.getParagraphs( 'a\n\n{{b}}\n\nc' ) )
	self:assertDeepEquals( {
		'X1',
		'{{X2}} X3 {{X4}}',
	}, parser.getParagraphs( parser.getSection( testpage, 'Paragraphs' ) ) )
end

function Suite:testTemplates()
	self:assertDeepEquals( {}, parser.getTemplates( 'a' ) )
	self:assertDeepEquals( { '{{a}}' }, parser.getTemplates( '{{a}}' ) )
	self:assertDeepEquals( { '{{b}}' }, parser.getTemplates( 'a{{b}}c' ) )
	self:assertDeepEquals( { '{{a|b=c}}' }, parser.getTemplates( '{{a|b=c}}' ) )
	self:assertDeepEquals( { '{{a\n|b=c\n}}' }, parser.getTemplates( '{{a\n|b=c\n}}' ) )
	self:assertDeepEquals( { '{{b}}', '{{d}}' }, parser.getTemplates( 'a{{b}}c{{d}}e' ) )
	self:assertDeepEquals( { '{{b}}', '{{d}}' }, parser.getTemplates( 'a{{b}}c{{d}}e' ) )
	self:assertDeepEquals( { '{{a|b={{c}}}}' }, parser.getTemplates( '{{a|b={{c}}}}' ) )
	self:assertDeepEquals( {
		'{{X2}}',
		'{{X3}}',
		'{{X4}}',
		'{{X11\n|b=c\n}}',
		'{{X12\n|b=d\n}}',
		'{{X2}}',
		'{{X4}}',
		'{{X5}}',
		'{{reflist}}',
		'{{reflist|group=i}}',
		'{{Infobox\n|a=1\n|b=2\n|d=4\n|c=3\n}}'
	}, parser.getTemplates( testpage ) )
end

function Suite:testTemplate()
	self:assertEquals( '{{a}}', parser.getTemplate( '{{a}}', 'a' ) )
	self:assertEquals( '{{a|b=c}}', parser.getTemplate( '{{a|b=c}}', 'a' ) )
	self:assertEquals( '{{a|b=c}}', parser.getTemplate( '{{a|b=c}}', 'A' ) )
	self:assertEquals( '{{Infobox\n|a=1\n|b=2\n|d=4\n|c=3\n}}', parser.getTemplate( testpage, 'Infobox' ) )
end

function Suite:testTemplateParameters()
	self:assertDeepEquals( { [1]='b' }, parser.getTemplateParameters( '{{a|b}}' ) )
	--self:assertDeepEquals( { [1]='b' }, parser.getTemplateParameters( '{{a|1=b}}' ) )
	self:assertDeepEquals( { [1]='b',['c']='1' }, parser.getTemplateParameters( '{{a|b|c=1}}' ) )
	self:assertDeepEquals( { [1]='b',['c']='d' }, parser.getTemplateParameters( '{{a|b|c=d}}' ) )
	self:assertDeepEquals( { ['b']='c' }, parser.getTemplateParameters( '{{a|b=c}}' ) )
	self:assertDeepEquals( { ['b']='c', ['d']='e' }, parser.getTemplateParameters( '{{a|b=c|d=e}}' ) )
end

function Suite:testTags()
	self:assertDeepEquals( {}, parser.getTags( 'a' ) )
	self:assertDeepEquals( {}, parser.getTags( '<!--a-->' ) )
	self:assertDeepEquals( { '<div>a' }, parser.getTags( '<div>a' ) )
	self:assertDeepEquals( { '<div></div>' }, parser.getTags( '<div></div>' ) )
	self:assertDeepEquals( { '<div></div>' }, parser.getTags( 'a<div></div>b' ) )
	self:assertDeepEquals( { '<div>a</div>' }, parser.getTags( '<div>a</div>' ) )
	self:assertDeepEquals( { '<div>b</div>' }, parser.getTags( 'a<div>b</div>c' ) )
	self:assertDeepEquals( { '< div >a</ div >' }, parser.getTags( '< div >a</ div >' ) )
	self:assertDeepEquals( { '<div class="a">b</div>' }, parser.getTags( '<div class="a">b</div>' ) )
	self:assertDeepEquals( { '<div><div></div></div>', '<div></div>' }, parser.getTags( '<div><div></div></div>' ) )
	self:assertDeepEquals( { '<div>b<div>c</div>d</div>', '<div>c</div>' }, parser.getTags( 'a<div>b<div>c</div>d</div>e' ) )
	self:assertDeepEquals( { '<div><div><span>a</span></div></div>', '<div><span>a</span></div>', '<span>a</span>' }, parser.getTags( '<div><div><span>a</span></div></div>' ) )
	self:assertDeepEquals( {
		'<gallery>\nFile:A.png|g<ref>g</ref>\nFile:B.png\n</gallery>', 
		'<ref>g</ref>', 
		'<br>', 
		'<br />', 
		'<hr>', 
		'<div>a<div>b</div></div>', 
		'<div>b</div>', 
		'<span class="a">b<span id="c">d</span></span>', 
		'<span id="c">d</span>', 
		'<section begin="a" />', 
		'<section end="a" />', 
		'<section begin="b" />', 
		'<section end="b" />', 
		'<section begin="c" />', 
		'<section end="c" />', 
		'<ref>b</ref>', 
		'<ref name="d">e</ref>', 
		'<ref name="d" />', 
		'<ref name="h" group="i">j</ref>', 
		'<ref name="l" />', 
		'<ref name="l">m</ref>', 
		'<noinclude>b</noinclude>', 
	}, parser.getTags( testpage ) )
end

function Suite:testTagName()
	self:assertEquals( nil, parser.getTagName( 'abc' ) )
	self:assertEquals( 'ref', parser.getTagName( '<ref>' ) )
	self:assertEquals( 'ref', parser.getTagName( '< ref />' ) )
	self:assertEquals( 'ref', parser.getTagName( '< ref name="a" />' ) )
	self:assertEquals( 'ref', parser.getTagName( '<ref>a</ref>' ) )
	self:assertEquals( 'ref', parser.getTagName( '<ref name = a >b</ref>' ) )
end

function Suite:testTagAttribute()
	self:assertEquals( nil, parser.getTagAttribute( '<ref>', 'name' ) )
	self:assertEquals( 'a', parser.getTagAttribute( '<ref name=a>', 'name' ) )
	self:assertEquals( 'b', parser.getTagAttribute( '<ref name="b">', 'name' ) )
	self:assertEquals( 'c', parser.getTagAttribute( '< ref name = "c" />', 'name' ) )
end

function Suite:testGalleries()
	self:assertDeepEquals( {}, parser.getGalleries( 'a' ) )
	self:assertDeepEquals( { '<gallery>a</gallery>' }, parser.getGalleries( '<gallery>a</gallery>' ) )
	self:assertDeepEquals( { '<gallery>b</gallery>' }, parser.getGalleries( 'a<gallery>b</gallery>c' ) )
	self:assertDeepEquals( { '<gallery>\nFile:A.png\nFile:B.png\n</gallery>' }, parser.getGalleries( '<gallery>\nFile:A.png\nFile:B.png\n</gallery>' ) )
	self:assertDeepEquals( { '<gallery>\nFile:A.png\nFile:B.png\n</gallery>' }, parser.getGalleries( 'a<gallery>\nFile:A.png\nFile:B.png\n</gallery>b' ) )
	self:assertDeepEquals( {
		'<gallery>\nFile:A.png|g<ref>g</ref>\nFile:B.png\n</gallery>', 
	}, parser.getGalleries( testpage ) )
end

function Suite:testReferences()
	self:assertDeepEquals( {}, parser.getReferences( 'a' ) )
	self:assertDeepEquals( { '<ref>a</ref>' }, parser.getReferences( '<ref>a</ref>' ) )
	self:assertDeepEquals( { '<ref>b</ref>' }, parser.getReferences( 'a<ref>b</ref>c' ) )
	self:assertDeepEquals( { '<ref>b</ref>', '<ref>d</ref>' }, parser.getReferences( 'a<ref>b</ref>c<ref>d</ref>' ) )
	self:assertDeepEquals( { '<ref name="b">c</ref>', '<ref name="b" />' }, parser.getReferences( 'a<ref name="b">c</ref>d<ref name="b" />' ) )
	self:assertDeepEquals( {
		'<ref>g</ref>', 
		'<ref>b</ref>', 
		'<ref name="d">e</ref>', 
		'<ref name="d" />', 
		'<ref name="h" group="i">j</ref>', 
		'<ref name="l" />', 
		'<ref name="l">m</ref>', 
	}, parser.getReferences( testpage ) )
end

function Suite:testTables()
	self:assertDeepEquals( {}, parser.getTables( 'a' ) )
	self:assertDeepEquals( { '{|\n!b\n|}' }, parser.getTables( 'a\n{|\n!b\n|}\nc' ) )
	self:assertDeepEquals( { '{|\n!b\n|}', '{|\n|d\n|}', '{|id="e"\n|e\n|}' }, parser.getTables( 'a\n{|\n!b\n|}\nc\n{|\n|d\n|}\n{|id="e"\n|e\n|}f' ) )
	self:assertDeepEquals( {
		'{|\n!b\n|}', 
		'{|\n|d\n|}', 
		'{|id="e"\n|e\n|}', 
		'{|\n!c\n|}', 
		'{|\n|X2\n|}', 
		'{|\n|e\n|}', 
		'{|\n|k\n|}', 
		'{|\n|e\n|}', 
		'{|\n|k\n|}', 
	}, parser.getTables( testpage ) )
end

function Suite:testTableAttribute()
	self:assertEquals( nil, parser.getTableAttribute( '{|\n|a\n|}', 'id' ) )
	self:assertEquals( 'a', parser.getTableAttribute( '{| id=a\n|a\n|}', 'id' ) )
	self:assertEquals( 'b', parser.getTableAttribute( '{| id="b" class="foo"\n|a\n|}', 'id' ) )
	self:assertEquals( 'c', parser.getTableAttribute( '{| class="foo" id="c" \n|a\n|}', 'id' ) )
end

function Suite:testLinks()
	self:assertDeepEquals( {}, parser.getLinks( 'a' ) )
	self:assertDeepEquals( { '[[a]]' }, parser.getLinks( '[[a]]' ) )
	self:assertDeepEquals( { '[[a|b]]' }, parser.getLinks( '[[a|b]]' ) )
	self:assertDeepEquals( { '[[b]]' }, parser.getLinks( 'a[[b]]c' ) )
	self:assertDeepEquals( { '[[b]]', '[[d]]' }, parser.getLinks( 'a[[b]]c[[d]]e' ) )
	self:assertDeepEquals( {
		'[[Module:WikitextParser/testcases]]', 
		'[[link]]', 
		'[[File:Name.jpg|thumb|X1]]', 
		'[[File:A.png]]', 
		'[[File:C.png]]', 
		'[[b]]', 
		'[[d]]', 
		'[[Module talk:Transcluder/testcases]]', 
		'[[module talk:Transcluder/testcases]]', 
		'[[Module talk:Transcluder/testcases|a]]', 
		'[[module talk:Transcluder/testcases|a]]', 
		'[[File:A.png]]', 
		'[[File:f.png]]', 
		'[[File:A.png]]', 
		'[[File:f.png]]', 
		'[[Category:X1]]', 
		'[[Category:X2]]', 
		'[[Category:X3]]', 
	}, parser.getLinks( testpage ) )
end

function Suite:testCategories()
	self:assertDeepEquals( {}, parser.getCategories( 'a' ) )
	self:assertDeepEquals( {}, parser.getCategories( '[[a]]' ) )
	self:assertDeepEquals( { '[[Category:a]]' }, parser.getCategories( '[[Category:a]]' ) )
	self:assertDeepEquals( { '[[ category : a ]]' }, parser.getCategories( '[[ category : a ]]' ) )
	self:assertDeepEquals( { '[[Category:b]]' }, parser.getCategories( 'a[[Category:b]]c' ) )
	self:assertDeepEquals( { '[[Category:b]]', '[[Category:c]]' }, parser.getCategories( 'a[[Category:b]][[Category:c]]d' ) )
	self:assertDeepEquals( {
		'[[Category:X1]]', 
		'[[Category:X2]]', 
		'[[Category:X3]]', 
	}, parser.getCategories( testpage ) )
end

function Suite:testFiles()
	self:assertDeepEquals( {}, parser.getFiles( 'a' ) )
	self:assertDeepEquals( {}, parser.getFiles( '[[a]]' ) )
	self:assertDeepEquals( { '[[File:a]]' }, parser.getFiles( '[[File:a]]' ) )
	self:assertDeepEquals( { '[[ file : a ]]' }, parser.getFiles( '[[ file : a ]]' ) )
	self:assertDeepEquals( { '[[File:b]]' }, parser.getFiles( 'a[[File:b]]c' ) )
	self:assertDeepEquals( { '[[File:b]]', '[[File:c]]' }, parser.getFiles( 'a[[File:b]][[File:c]]d' ) )
	self:assertDeepEquals( {
		'[[File:Name.jpg|thumb|X1]]', 
		'[[File:A.png]]', 
		'[[File:C.png]]', 
		'[[File:A.png]]', 
		'[[File:f.png]]', 
		'[[File:A.png]]', 
		'[[File:f.png]]', 
	}, parser.getFiles( testpage ) )
end

function Suite:testFileName()
	self:assertEquals( 'Example.jpg', parser.getFileName( '[[File:Example.jpg]]' ) )
	self:assertEquals( 'Example.jpg', parser.getFileName( '[[File:Example.jpg|thumb]]' ) )
	self:assertEquals( 'Example.jpg', parser.getFileName( '[[ File : Example.jpg | thumb ]]' ) )
end

function Suite:testExternalLinks()
	self:assertDeepEquals( {}, parser.getExternalLinks( '' ) )
	self:assertDeepEquals( {}, parser.getExternalLinks( 'a' ) )
	self:assertDeepEquals( {}, parser.getExternalLinks( '[[a]]' ) )
	self:assertDeepEquals( { '[//www.example.com]' }, parser.getExternalLinks( '[//www.example.com]' ) )
	self:assertDeepEquals( { '[http://www.example.com]' }, parser.getExternalLinks( '[http://www.example.com]' ) )
	self:assertDeepEquals( { '[https://www.example.com]' }, parser.getExternalLinks( '[https://www.example.com]' ) )
	self:assertDeepEquals( { '[//www.example.com example]' }, parser.getExternalLinks( '[//www.example.com example]' ) )
	self:assertDeepEquals( { '[http://www.example.com example]' }, parser.getExternalLinks( '[http://www.example.com example]' ) )
	self:assertDeepEquals( { '[https://www.example.com example]' }, parser.getExternalLinks( '[https://www.example.com example]' ) )
end

return Suite