Module:Arguments/testcases

 localgetArgs=require('Module:Arguments/sandbox').getArgs
 localScribuntoUnit=require('Module:ScribuntoUnit')
 localsuite=ScribuntoUnit:new()
 locallibName='Arguments'

 --------------------------------------------------------------------------
 -- Default values
 --------------------------------------------------------------------------

 locald={}
 d.frameTitle='Frame title'
 d.parentTitle='Parent title'

 -- Precedence-testing values
 d.firstFrameArg='first frame argument'
 d.firstParentArg='first parent argument'
 d.secondParentArg='second parent argument'
 d.uniqueFrameArg='unique frame argument'
 d.uniqueFrameArgKey='uniqueFrameArgKey'
 d.uniqueParentArg='unique parent argument'
 d.uniqueParentArgKey='uniqueParentArgKey'

 -- Trimming and whitespace values.
 -- Whitespace gets trimmed from named parameters, so keys for these need
 -- to be numbers to make this a proper test.
 d.blankArg=''
 d.blankArgKey=100
 d.spacesArg='\n '
 d.spacesArgKey=101
 d.untrimmedArg='\n foo bar '
 d.untrimmedArgKey=102
 d.trimmedArg='foo bar'
 d.valueFuncValue='valueFuncValue'
 d.defaultValueFunc=function()returnd.valueFuncValueend
 d.translate={
 foo='F00',
 bar='8@r',
 baz='8@z',
 qux='qUx'
 }

 -- Helper to run all tests using sandbox version of the library from the debug console. To run against main lib, use =p.run()
 functionsuite.runSandbox()
 localframe=mw.getCurrentFrame():newChild{title='testcases',args={module=libName..'/sandbox',displayMode='log'}}
 returnsuite.run(frame)
 end

 -- Allow test runner to use the sandbox and the primary versions of the library with the same testcases
 functionsuite:module()
 returnrequire('Module:'..(self.frameandself.frame.args.moduleorlibName))
 end

 --[[
  Library-specific tests
 ]]

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

 functionsuite.getFrames(frameTitle,frameArgs,parentTitle,parentArgs)
 frameTitle=frameTitleord.frameTitle
 frameArgs=frameArgsor{
 d.firstFrameArg,
 [d.uniqueFrameArgKey]=d.uniqueFrameArg,
 [d.blankArgKey]=d.blankArg,
 [d.spacesArgKey]=d.spacesArg,
 [d.untrimmedArgKey]=d.untrimmedArg
 }
 parentTitle=parentTitleord.parentTitle
 parentArgs=parentArgsor{
 d.firstParentArg,
 d.secondParentArg,
 [d.uniqueParentArgKey]=d.uniqueParentArg
 }
 localcurrentFrame=mw.getCurrentFrame()
 localparent=currentFrame:newChild{title=parentTitle,args=parentArgs}
 localframe=parent:newChild{title=frameTitle,args=frameArgs}
 returnframe,parent
 end

 functionsuite.getDefaultArgs(options,frameTitle,frameArgs,parentTitle,parentArgs)
 localframe,parent=suite.getFrames(frameTitle,frameArgs,parentTitle,parentArgs)
 localargs=getArgs(frame,options)
 returnargs
 end

 functionsuite:assertError(func,...)
 -- Asserts that executing the function func results in an error.
 -- Parameters after func are func's arguments.
 localsuccess,msg=pcall(func,...)
 self:assertFalse(success)
 end

 functionsuite:assertNumberOfIterations(expected,iterator,t)
 localnoIterations=0
 fork,viniterator(t)do
 noIterations=noIterations+1
 end
 self:assertEquals(expected,noIterations)
 end

 --------------------------------------------------------------------------
 -- Test precedence
 --------------------------------------------------------------------------

 functionsuite:assertDefaultPrecedence(args)
 self:assertEquals(d.firstFrameArg,args[1])
 self:assertEquals(d.secondParentArg,args[2])
 self:assertEquals(d.uniqueFrameArg,args[d.uniqueFrameArgKey])
 self:assertEquals(d.uniqueParentArg,args[d.uniqueParentArgKey])
 end

 functionsuite:testDefaultPrecedence()
 self:assertDefaultPrecedence(suite.getDefaultArgs())
 end

 functionsuite:testDefaultPrecedenceThroughWrapper()
 self:assertDefaultPrecedence(suite.getDefaultArgs{wrappers={d.parentTitle},parentOnly=false})
 end

 functionsuite:testDefaultPrecedenceThroughNonWrapper()
 self:assertDefaultPrecedence(suite.getDefaultArgs({wrappers=d.parentTitle,frameOnly=false},nil,nil,'Not the parent title'))
 end

 functionsuite:assertParentFirst(args)
 self:assertEquals(d.firstParentArg,args[1])
 self:assertEquals(d.secondParentArg,args[2])
 self:assertEquals(d.uniqueFrameArg,args[d.uniqueFrameArgKey])
 self:assertEquals(d.uniqueParentArg,args[d.uniqueParentArgKey])
 end

 functionsuite:testParentFirst()
 self:assertParentFirst(suite.getDefaultArgs{parentFirst=true})
 end

 functionsuite:testParentFirstThroughWrapper()
 self:assertParentFirst(suite.getDefaultArgs{wrappers={d.parentTitle},parentOnly=false,parentFirst=true})
 end

 functionsuite:testParentFirstThroughNonWrapper()
 self:assertParentFirst(suite.getDefaultArgs({wrappers=d.parentTitle,frameOnly=false,parentFirst=true},nil,nil,'Not the parent title'))
 end

 functionsuite:assertParentOnly(args)
 self:assertEquals(d.firstParentArg,args[1])
 self:assertEquals(d.secondParentArg,args[2])
 self:assertEquals(nil,args[d.uniqueFrameArgKey])
 self:assertEquals(d.uniqueParentArg,args[d.uniqueParentArgKey])
 end

 functionsuite:testParentOnly()
 self:assertParentOnly(suite.getDefaultArgs{parentOnly=true})
 end

 functionsuite:testParentOnlyThroughWrapper()
 self:assertParentOnly(suite.getDefaultArgs{wrappers={d.parentTitle}})
 end

 functionsuite:testParentOnlyThroughSandboxWrapper()
 self:assertParentOnly(suite.getDefaultArgs({wrappers=d.parentTitle},nil,nil,d.parentTitle..'/sandbox'))
 end

 functionsuite:assertFrameOnly(args)
 self:assertEquals(d.firstFrameArg,args[1])
 self:assertEquals(nil,args[2])
 self:assertEquals(d.uniqueFrameArg,args[d.uniqueFrameArgKey])
 self:assertEquals(nil,args[d.uniqueParentArgKey])
 end

 functionsuite:testFrameOnly()
 self:assertFrameOnly(suite.getDefaultArgs{frameOnly=true})
 end

 functionsuite:testFrameOnlyThroughNonWrapper()
 self:assertFrameOnly(suite.getDefaultArgs({wrappers=d.parentTitle},nil,nil,'Not the parent title'))
 end

 functionsuite:testDefaultPrecedenceWithWhitespace()
 localframe,parent=suite.getFrames(
 d.frameTitle,
 {' '},
 d.parentTitle,
 {d.firstParentArg}
 )
 localargs=getArgs(frame)
 self:assertEquals(d.firstParentArg,args[1])
 end

 --------------------------------------------------------------------------
 -- Test trimming and blank removal
 --------------------------------------------------------------------------

 functionsuite:testDefaultTrimmingAndBlankRemoval()
 localargs=suite.getDefaultArgs()
 self:assertEquals(nil,args[d.blankArgKey])
 self:assertEquals(nil,args[d.spacesArgKey])
 self:assertEquals(d.trimmedArg,args[d.untrimmedArgKey])
 end

 functionsuite:testRemoveBlanksButNoTrimming()
 localargs=suite.getDefaultArgs{trim=false}
 self:assertEquals(nil,args[d.blankArgKey])
 self:assertEquals(nil,args[d.spacesArgKey])
 self:assertEquals(d.untrimmedArg,args[d.untrimmedArgKey])
 end

 functionsuite:testTrimButNoBlankRemoval()
 localargs=suite.getDefaultArgs{removeBlanks=false}
 self:assertEquals(d.blankArg,args[d.blankArgKey])
 self:assertEquals('',args[d.spacesArgKey])
 self:assertEquals(d.trimmedArg,args[d.untrimmedArgKey])
 end

 functionsuite:testNoTrimOrBlankRemoval()
 localargs=suite.getDefaultArgs{trim=false,removeBlanks=false}
 self:assertEquals(d.blankArg,args[d.blankArgKey])
 self:assertEquals(d.spacesArg,args[d.spacesArgKey])
 self:assertEquals(d.untrimmedArg,args[d.untrimmedArgKey])
 end

 --------------------------------------------------------------------------
 -- Test valueFunc
 --------------------------------------------------------------------------

 functionsuite:testValueFunc()
 localargs=suite.getDefaultArgs{valueFunc=d.defaultValueFunc}
 self:assertEquals(d.valueFuncValue,args['some random key: sdfaliwyda'])
 end

 functionsuite:testValueFuncPrecedence()
 localargs=suite.getDefaultArgs{
 trim=false,
 removeBlanks=false,
 valueFunc=d.defaultValueFunc
 }
 self:assertEquals(d.valueFuncValue,args[1])
 self:assertEquals(d.valueFuncValue,args['some random key: gekjabawyvy'])
 end

 functionsuite:testValueFuncKey()
 localargs=suite.getDefaultArgs{valueFunc=function(key,value)
 return'valueFunc key: '..key
 end}
 self:assertEquals('valueFunc key: foo',args.foo)
 end

 functionsuite:testValueFuncValue()
 localargs=suite.getDefaultArgs{valueFunc=function(key,value)
 return'valueFunc value: '..value
 end}
 self:assertEquals(
 'valueFunc value: '..d.uniqueFrameArg,
 args[d.uniqueFrameArgKey]
 )
 end

 --------------------------------------------------------------------------
 -- Test adding new arguments
 --------------------------------------------------------------------------

 functionsuite:testAddingNewArgs()
 localargs=suite.getDefaultArgs()
 self:assertEquals(nil,args.newKey)
 args.newKey='some new key'
 self:assertEquals('some new key',args.newKey)
 end

 functionsuite:testAddingNewBlankArgs()
 localargs=suite.getDefaultArgs()
 self:assertEquals(nil,args.newKey)
 args.newKey=''
 self:assertEquals('',args.newKey)
 end

 functionsuite:testAddingNewSpacesArgs()
 localargs=suite.getDefaultArgs()
 self:assertEquals(nil,args.newKey)
 args.newKey=' '
 self:assertEquals(' ',args.newKey)
 end

 functionsuite:testOverwriting()
 localargs=suite.getDefaultArgs()
 self:assertEquals(d.firstFrameArg,args[1])
 args[1]='a new first frame argument'
 self:assertEquals('a new first frame argument',args[1])
 end

 functionsuite:testOverwritingWithNil()
 localargs=suite.getDefaultArgs()
 self:assertEquals(d.firstFrameArg,args[1])
 args[1]=nil
 self:assertEquals(nil,args[1])
 end

 functionsuite:testOverwritingWithBlank()
 localargs=suite.getDefaultArgs()
 self:assertEquals(d.firstFrameArg,args[1])
 args[1]=''
 self:assertEquals('',args[1])
 end

 functionsuite:testOverwritingWithSpaces()
 localargs=suite.getDefaultArgs()
 self:assertEquals(d.firstFrameArg,args[1])
 args[1]=' '
 self:assertEquals(' ',args[1])
 end

 functionsuite:testReadOnly()
 localargs=suite.getDefaultArgs{readOnly=true}
 localfunctiontestFunc()
 args.newKey='some new value'
 end
 self:assertError(testFunc)
 end

 functionsuite:testNoOverwriteExistingKey()
 localargs=suite.getDefaultArgs{noOverwrite=true}
 self:assertEquals(d.firstFrameArg,args[1])
 localfunctiontestFunc()
 args[1]='a new first frame argument'
 end
 self:assertError(testFunc)
 end

 functionsuite:testNoOverwriteNewKey()
 localargs=suite.getDefaultArgs{noOverwrite=true}
 self:assertEquals(nil,args.newKey)
 args.newKey='some new value'
 self:assertEquals('some new value',args.newKey)
 end

 --------------------------------------------------------------------------
 -- Test bad input
 --------------------------------------------------------------------------

 functionsuite:testBadFrameInput()
 self:assertError(getArgs,'foo')
 self:assertError(getArgs,9)
 self:assertError(getArgs,true)
 self:assertError(getArgs,function()returntrueend)
 end

 functionsuite:testBadOptionsInput()
 self:assertError(getArgs,{},'foo')
 self:assertError(getArgs,{},9)
 self:assertError(getArgs,{},true)
 self:assertError(getArgs,{},function()returntrueend)
 end

 functionsuite:testBadValueFuncInput()
 self:assertError(getArgs,{},{valueFunc='foo'})
 self:assertError(getArgs,{},{valueFunc=9})
 self:assertError(getArgs,{},{valueFunc=true})
 self:assertError(getArgs,{},{valueFunc={}})
 end

 --------------------------------------------------------------------------
 -- Test iterator metamethods
 --------------------------------------------------------------------------

 functionsuite:testPairs()
 localargs=getArgs{'foo','bar',baz='qux'}
 self:assertNumberOfIterations(3,pairs,args)
 end

 functionsuite:testIpairs()
 localargs=getArgs{'foo','bar',baz='qux'}
 self:assertNumberOfIterations(2,ipairs,args)
 end

 functionsuite:testNoNilsinPairs()
 -- Test that when we use pairs, we don't iterate over any nil values
 -- that have been memoized.
 localargs=getArgs{''}
 localtemp=args[1]-- Memoizes the nil
 self:assertNumberOfIterations(0,pairs,args)
 end

 functionsuite:testNoNilsinIpairs()
 -- Test that when we use ipairs, we don't iterate over any nil values
 -- that have been memoized.
 localargs=getArgs{''}
 localtemp=args[1]-- Memoizes the nil
 self:assertNumberOfIterations(0,ipairs,args)
 end

 functionsuite:testDeletedArgsInPairs()
 -- Test that when we use pairs, we don't iterate over any values that have
 -- been explicitly set to nil.
 localargs=getArgs{'foo'}
 args[1]=nil
 self:assertNumberOfIterations(0,pairs,args)
 end

 functionsuite:testDeletedArgsInIpairs()
 -- Test that when we use ipairs, we don't iterate over any values that have
 -- been explicitly set to nil.
 localargs=getArgs{'foo'}
 args[1]=nil
 self:assertNumberOfIterations(0,ipairs,args)
 end

 functionsuite:testNoNilsInPairsAfterIndex()
 -- Test that when we use pairs, we don't iterate over any nils that
 -- might have been memoized after a value that is not present in the
 -- original args table is indexed.
 localargs=getArgs{}
 localtemp=args.someRandomValue-- Memoizes the nil
 self:assertNumberOfIterations(0,pairs,args)
 end

 functionsuite:testNoNilsInPairsAfterNewindex()
 -- Test that when we use pairs, we don't iterate over any nils that
 -- might have been memoized after a value that is not present in the
 -- original args table is added to the args table.
 localargs=getArgs{}
 args.newKey=nil-- The nil is memoized
 self:assertNumberOfIterations(0,pairs,args)
 end

 functionsuite:testNoTableLengthChangeWhileIterating()
 -- Test that the number of arguments doesn't change if we index the
 -- args table while iterating.
 -- (Note that the equivalent test is not needed for new arg table
 -- indexes, as that would be a user error - doing so produces
 -- undetermined behaviour in Lua's next() function.)
 localargs=getArgs{'foo','bar',baz='qux'}
 self:assertNumberOfIterations(3,pairs,args)
 fork,vinpairs(args)do
 localtemp=args[k..'foo']
 end
 self:assertNumberOfIterations(3,pairs,args)
 end

 functionsuite:testPairsPrecedenceWithWhitespace()
 localframe,parent=suite.getFrames(
 d.frameTitle,
 {' '},
 d.parentTitle,
 {d.firstParentArg}
 )
 localargs=getArgs(frame)
 localactual
 fork,vinpairs(args)do
 actual=v
 end
 self:assertEquals(d.firstParentArg,actual)
 -- Check that we have actually iterated.
 self:assertNumberOfIterations(1,pairs,args)
 end

 functionsuite:testPairsPrecedenceWithNil()
 localframe,parent=suite.getFrames(
 d.frameTitle,
 {},
 d.parentTitle,
 {d.firstParentArg}
 )
 localargs=getArgs(frame)
 localactual
 fork,vinpairs(args)do
 actual=v
 end
 self:assertEquals(d.firstParentArg,actual)
 -- Check that we have actually iterated.
 self:assertNumberOfIterations(1,pairs,args)
 end

 functionsuite:testIpairsEarlyExit()
 localmt={}
 functionmt.__index(t,k)
 ifk==1then
 return'foo'
 elseifk==2then
 return'bar'
 elseifk==3then
 error('Expanded argument 3 unnecessarily')
 end
 end
 functionmt.__pairs(t)
 error('Called pairs unnecessarily')
 end
 functionmt.__ipairs(t)
 -- Works just like the default ipairs, except respecting __index
 returnfunction(t,i)
 localv=t[i+1]
 ifv~=nilthen
 returni+1,v
 end
 end,t,0
 end
 localargs=getArgs(setmetatable({},mt))
 fork,vinipairs(args)do
 ifv=='bar'then
 break
 end
 end
 end

 --------------------------------------------------------------------------
 -- Test argument translation
 --------------------------------------------------------------------------

 functionsuite:testTranslationIndex()
 localargs=getArgs({F00='one',['8@r']='two',['8@z']='three',qUx='four',foo='nope',untranslated='yep'},{translate=d.translate})
 self:assertEquals('one',args.foo)
 self:assertEquals('two',args.bar)
 self:assertEquals('three',args.baz)
 self:assertEquals('four',args.qux)
 self:assertEquals('yep',args.untranslated)
 end

 functionsuite:testTranslationPairsWithAutoBacktranslate()
 localargs=getArgs({F00='one',['8@r']='two',['8@z']='three',qUx='four',foo='nope',untranslated='yep'},{translate=d.translate})
 localcleanArgs={}
 fork,vinpairs(args)do
 cleanArgs[k]=v
 end
 self:assertDeepEquals(
 {
 foo='one',
 bar='two',
 baz='three',
 qux='four',
 untranslated='yep'
 },
 cleanArgs
 )
 end

 functionsuite:testTranslationPairsWithBacktranslate()
 localargs=getArgs({F00='one',['8@r']='two',['8@z']='three',qUx='four',foo='nope',untranslated='yep'},{translate=d.translate,backtranslate={F00='foo'}})
 localcleanArgs={}
 fork,vinpairs(args)do
 cleanArgs[k]=v
 end
 self:assertDeepEquals(
 {
 foo='one',
 ['8@r']='two',
 ['8@z']='three',
 qUx='four',
 untranslated='yep'
 },
 cleanArgs
 )
 end

 functionsuite:testTranslationPairsWithoutBacktranslate()
 localargs=getArgs({F00='one',['8@r']='two',['8@z']='three',qUx='four',foo='nope',untranslated='yep'},{translate=d.translate,backtranslate=false})
 localcleanArgs={}
 fork,vinpairs(args)do
 cleanArgs[k]=v
 end
 self:assertDeepEquals(
 {
 F00='one',
 ['8@r']='two',
 ['8@z']='three',
 qUx='four',
 foo='nope',
 untranslated='yep'
 },
 cleanArgs
 )
 end

 functionsuite:testTranslationNewindex()
 localargs=getArgs({F00='one',['8@r']='two',['8@z']='three',qUx='four',foo='nope',untranslated='yep'},{translate=d.translate,backtranslate=false})
 args.foo='changed1'
 args.untranslated='changed2'
 localcleanArgs={}
 fork,vinpairs(args)do
 cleanArgs[k]=v
 end
 self:assertDeepEquals(
 {
 F00='changed1',
 ['8@r']='two',
 ['8@z']='three',
 qUx='four',
 foo='nope',
 untranslated='changed2'
 },
 cleanArgs
 )
 end

 functionsuite:test_argument()
 localcurrentFrame=mw.getCurrentFrame()
 currentFrame.args[5]=555;
 localargs=getArgs(currentFrame)
 self:assertEquals('nil',type(args.foo))
 end

 returnsuite