Jump to content
Wikipedia The Free Encyclopedia

Module:Date table sorting/testcases

From Wikipedia, the free encyclopedia
This is the test cases page for the module Module:Date table sorting. Results of the test cases.
 localmDts=require('Module:Date table sorting/sandbox')-- the module to be tested
 localDts=mDts._exportClasses().Dts-- the Dts class
 localScribuntoUnit=require('Module:ScribuntoUnit')
 localsuite=ScribuntoUnit:new()

 -------------------------------------------------------------------------------
 -- Helper functions and values
 -------------------------------------------------------------------------------

 suite.currentYear=os.date('*t').year
 suite.nowrapPattern='^<span data%-sort%-value="[^"<>]-" style="white%-space:nowrap">[^<>]-</span>$'

 suite.offValues={'off','no','NO','n','false',false}
 suite.onValues={'on','yes','YES','y','true',true}
 localfunctionmakeOnOffAsserts(fragment)
 suite['assert'..fragment..'WhenOn']=function(self,first,func,...)
 fori,oninipairs(suite.onValues)do
 self['assert'..fragment](self,first,func(on),...)
 end
 end
 suite['assert'..fragment..'WhenOff']=function(self,first,func,...)
 fori,offinipairs(suite.offValues)do
 self['assert'..fragment](self,first,func(off),...)
 end
 end
 end
 makeOnOffAsserts('Equals')
 makeOnOffAsserts('StringContains')
 makeOnOffAsserts('NotStringContains')

 functionsuite:assertErrorContains(pattern,func,plain)
 localsuccess,msg=pcall(func)
 self:assertFalse(success)
 self:assertStringContains(pattern,msg,plain)
 end

 functionsuite:assertDateEquals(year,month,day,args)
 localdtsObj=Dts.new(args)
 self:assertEquals(year,dtsObj.year)
 self:assertEquals(month,dtsObj.month)
 self:assertEquals(day,dtsObj.day)
 end

 functionsuite:assertSortKeyEquals(expected,args)
 localdtsObj=Dts.new(args)
 self:assertEquals(expected,dtsObj:makeSortKey())
 end

 functionsuite:assertDisplayEquals(expected,args)
 localdtsObj=Dts.new(args)
 self:assertEquals(expected,dtsObj:makeDisplay())
 end

 -------------------------------------------------------------------------------
 -- Date parameter tests
 -------------------------------------------------------------------------------

 functionsuite:testDateYMD()
 self:assertDateEquals(2000,1,27,{2000,1,27})
 end

 functionsuite:testDateYMonthD()
 self:assertDateEquals(2000,1,27,{2000,'January',27})
 self:assertDateEquals(2000,1,27,{2000,'january',27})
 end

 functionsuite:testDateYMonD()
 self:assertDateEquals(2000,1,27,{2000,'Jan',27})
 self:assertDateEquals(2000,1,27,{2000,'jan',27})
 end

 functionsuite:testDateYM()
 self:assertDateEquals(2000,1,nil,{2000,1})
 end

 functionsuite:testDateYD()
 self:assertDateEquals(2000,nil,27,{2000,nil,27})
 end

 functionsuite:testDateMD()
 self:assertDateEquals(nil,1,27,{nil,1,27})
 end

 functionsuite:testDateY()
 self:assertDateEquals(2000,nil,nil,{2000})
 end

 functionsuite:testDateM()
 self:assertDateEquals(nil,1,nil,{nil,1})
 end

 functionsuite:testDateD()
 self:assertDateEquals(nil,nil,27,{nil,nil,27})
 end

 functionsuite:testDateNegativeYear()
 self:assertDateEquals(-2000,1,27,{-2000,1,27})
 end

 functionsuite:testDateString()
 self:assertDateEquals(2000,1,27,{'2000','1','27'})
 end

 functionsuite:testDateAllMonths()
 self:assertDateEquals(nil,1,nil,{nil,'January',nil})
 self:assertDateEquals(nil,2,nil,{nil,'February',nil})
 self:assertDateEquals(nil,3,nil,{nil,'March',nil})
 self:assertDateEquals(nil,4,nil,{nil,'April',nil})
 self:assertDateEquals(nil,5,nil,{nil,'May',nil})
 self:assertDateEquals(nil,6,nil,{nil,'June',nil})
 self:assertDateEquals(nil,7,nil,{nil,'July',nil})
 self:assertDateEquals(nil,8,nil,{nil,'August',nil})
 self:assertDateEquals(nil,9,nil,{nil,'September',nil})
 self:assertDateEquals(nil,10,nil,{nil,'October',nil})
 self:assertDateEquals(nil,11,nil,{nil,'November',nil})
 self:assertDateEquals(nil,12,nil,{nil,'December',nil})
 end

 functionsuite:testDateAllMons()
 self:assertDateEquals(nil,1,nil,{nil,'Jan',nil})
 self:assertDateEquals(nil,2,nil,{nil,'Feb',nil})
 self:assertDateEquals(nil,3,nil,{nil,'Mar',nil})
 self:assertDateEquals(nil,4,nil,{nil,'Apr',nil})
 self:assertDateEquals(nil,5,nil,{nil,'May',nil})
 self:assertDateEquals(nil,6,nil,{nil,'Jun',nil})
 self:assertDateEquals(nil,7,nil,{nil,'Jul',nil})
 self:assertDateEquals(nil,8,nil,{nil,'Aug',nil})
 self:assertDateEquals(nil,9,nil,{nil,'Sep',nil})
 self:assertDateEquals(nil,10,nil,{nil,'Oct',nil})
 self:assertDateEquals(nil,11,nil,{nil,'Nov',nil})
 self:assertDateEquals(nil,12,nil,{nil,'Dec',nil})
 end

 -------------------------------------------------------------------------------
 -- parseDate tests
 -------------------------------------------------------------------------------

 functionsuite:testParseYear()
 self:assertDateEquals(2000,nil,nil,{'2000'})
 end

 functionsuite:testParseNegativeYear()
 self:assertDateEquals(-2000,nil,nil,{'-2000'})
 end

 functionsuite:testParseSmallYear()
 self:assertDateEquals(12,nil,nil,{'12'})
 end

 functionsuite:testParseYYYYMMDD()
 self:assertDateEquals(2000,1,27,{'2000年01月27日'})
 self:assertDateEquals(2000,1,27,{'2000年1月27日'})
 self:assertDateEquals(2000,1,6,{'2000年01月06日'})
 self:assertDateEquals(2000,1,6,{'2000年01月06日'})
 end

 functionsuite:testParseDDMMYYYY()
 self:assertDateEquals(2000,1,27,{'27-01-2000'})
 self:assertDateEquals(2000,1,27,{'27-1-2000'})
 self:assertDateEquals(2000,1,6,{'06-01-2000'})
 end

 functionsuite:testParseYYYYMM()
 self:assertDateEquals(2000,1,nil,{'2000-01'})
 self:assertDateEquals(2000,1,nil,{'2000-1'})
 end

 functionsuite:testParseMonthYYYY()
 self:assertDateEquals(1418,2,nil,{'February 1418'})
 end

 functionsuite:testParseMonYYYY()
 self:assertDateEquals(1418,2,nil,{'Feb 1418'})
 end

 functionsuite:testParseDDMonthYYYY()
 self:assertDateEquals(1975,4,24,{'24 April 1975'})
 end

 functionsuite:testParseDDMonYYYY()
 self:assertDateEquals(1975,4,24,{'24 Apr 1975'})
 end

 functionsuite:testParseMonthDDYYYY()
 self:assertDateEquals(1975,4,24,{'April 24, 1975'})
 self:assertDateEquals(1975,4,24,{'April 24 1975'})
 end

 functionsuite:testParseMonDDYYYY()
 self:assertDateEquals(1975,4,24,{'Apr 24, 1975'})
 self:assertDateEquals(1975,4,24,{'Apr 24 1975'})
 end

 functionsuite:testParseMonth()
 self:assertDateEquals(nil,4,nil,{'April'})
 self:assertDateEquals(nil,4,nil,{'april'})
 end

 functionsuite:testParseMon()
 self:assertDateEquals(nil,4,nil,{'Apr'})
 self:assertDateEquals(nil,4,nil,{'apr'})
 end

 functionsuite:testParseDDMonth()
 self:assertDateEquals(nil,11,12,{'12 November'})
 end

 functionsuite:testParseDDMon()
 self:assertDateEquals(nil,11,12,{'12 Nov'})
 end

 functionsuite:testParseMonthDD()
 self:assertDateEquals(nil,11,12,{'November 12'})
 end

 functionsuite:testParseMonDD()
 self:assertDateEquals(nil,11,12,{'Nov 12'})
 end

 functionsuite:testParseDDMonthYYY()
 self:assertDateEquals(100,1,27,{'27 January 100'})
 end

 functionsuite:testParseDDMonth0YYY()
 self:assertDateEquals(100,1,27,{'27 January 0100'})
 end

 functionsuite:testParseDDMonth000Y()
 self:assertDateEquals(3,1,27,{'27 January 0003'})
 end

 functionsuite:testParseAllMonths()
 self:assertDateEquals(nil,1,nil,{'January'})
 self:assertDateEquals(nil,2,nil,{'February'})
 self:assertDateEquals(nil,3,nil,{'March'})
 self:assertDateEquals(nil,4,nil,{'April'})
 self:assertDateEquals(nil,5,nil,{'May'})
 self:assertDateEquals(nil,6,nil,{'June'})
 self:assertDateEquals(nil,7,nil,{'July'})
 self:assertDateEquals(nil,8,nil,{'August'})
 self:assertDateEquals(nil,9,nil,{'September'})
 self:assertDateEquals(nil,10,nil,{'October'})
 self:assertDateEquals(nil,11,nil,{'November'})
 self:assertDateEquals(nil,12,nil,{'December'})
 end

 functionsuite:testParseAllMons()
 self:assertDateEquals(nil,1,nil,{'Jan'})
 self:assertDateEquals(nil,2,nil,{'Feb'})
 self:assertDateEquals(nil,3,nil,{'Mar'})
 self:assertDateEquals(nil,4,nil,{'Apr'})
 self:assertDateEquals(nil,5,nil,{'May'})
 self:assertDateEquals(nil,6,nil,{'Jun'})
 self:assertDateEquals(nil,7,nil,{'Jul'})
 self:assertDateEquals(nil,8,nil,{'Aug'})
 self:assertDateEquals(nil,9,nil,{'Sep'})
 self:assertDateEquals(nil,10,nil,{'Oct'})
 self:assertDateEquals(nil,11,nil,{'Nov'})
 self:assertDateEquals(nil,12,nil,{'Dec'})
 end

 functionsuite:testParseSept()
 self:assertDateEquals(nil,9,nil,{'Sept'})
 self:assertDateEquals(nil,9,nil,{'sept'})
 self:assertDateEquals(2012,9,1,{'1 Sept 2012'})
 self:assertDateEquals(2012,9,1,{2012,'Sept',1})
 end

 -------------------------------------------------------------------------------
 -- Date error tests
 -------------------------------------------------------------------------------

 functionsuite:testInvalidDateError()
 self:assertErrorContains("'foo' is an invalid date",function()
 Dts.new{'foo'}
 end)
 end

 functionsuite:testZeroYearError()
 self:assertErrorContains('years cannot be zero',function()
 Dts.new{0}
 end)
 end

 functionsuite:testYearNonIntegerError()
 self:assertErrorContains('years must be an integer',function()
 Dts.new{2015.5}
 end)
 end

 functionsuite:testYearLowRangeError()
 self:assertErrorContains(
 'years cannot be less than −999,999,999,999',
 function()
 Dts.new{-1000000000000}
 end,
 true-- plain match
 )
 end

 functionsuite:testYearHighRangeError()
 self:assertErrorContains('years cannot be greater than 999,999,999,999',function()
 Dts.new{1000000000000}
 end)
 end

 functionsuite:testMonthError()
 self:assertErrorContains('months must be an integer between 1 and 12',function()
 Dts.new{2000,0}
 end)
 self:assertErrorContains('months must be an integer between 1 and 12',function()
 Dts.new{2000,13}
 end)
 end

 functionsuite:testDayError()
 self:assertErrorContains('days must be an integer between 1 and 31',function()
 Dts.new{2000,1,0}
 end)
 self:assertErrorContains('days must be an integer between 1 and 31',function()
 Dts.new{2000,1,32}
 end)
 end

 functionsuite:testBCError()
 self:assertErrorContains(
 "'foo' is not a valid era code (expected 'BC', 'BCE', 'AD' or 'CE')",
 function()
 Dts.new{2000,1,27,'foo'}
 end,
 true-- plain match
 )
 end

 -------------------------------------------------------------------------------
 -- Sort key tests
 -------------------------------------------------------------------------------

 functionsuite:testSortKeyYMD()
 suite:assertSortKeyEquals('000000002000-05-27-0000',{2000,5,27})
 suite:assertSortKeyEquals('000000002000-01-27-0000',{2000,1,27})
 suite:assertSortKeyEquals('000000002000-01-01-0000',{2000,1,1})
 suite:assertSortKeyEquals('000000000001-01-01-0000',{1,1,1})
 end

 functionsuite:testSortKeyYM()
 suite:assertSortKeyEquals('000000002000-05-01-0000',{2000,5,nil})
 end

 functionsuite:testSortKeyYD()
 suite:assertSortKeyEquals('000000002000-01-27-0000',{2000,nil,27})
 end

 functionsuite:testSortKeyMD()
 suite:assertSortKeyEquals('00000000'..suite.currentYear..'-05-27-0000',{nil,5,27})
 end

 functionsuite:testSortKeyY()
 suite:assertSortKeyEquals('000000002000-01-01-0000',{2000,nil,nil})
 end

 functionsuite:testSortKeyM()
 suite:assertSortKeyEquals('00000000'..suite.currentYear..'-05-01-0000',{nil,5,nil})
 end

 functionsuite:testSortKeyD()
 suite:assertSortKeyEquals('00000000'..suite.currentYear..'-01-27-0000',{nil,nil,27})
 end

 functionsuite:testSortKeyNegative()
 suite:assertSortKeyEquals('-999999999955-05-27-0000',{-45,5,27})
 end

 functionsuite:testSortKeyMaxYear()
 suite:assertSortKeyEquals('999999999999-01-01-0000',{999999999999})
 end

 functionsuite:testSortKeyMinYear()
 suite:assertSortKeyEquals('-000000000001-01-01-0000',{-999999999999})
 end

 functionsuite:testSortKeyBlank()
 suite:assertSortKeyEquals('999999999999-99-99-0000',{})
 end

 -------------------------------------------------------------------------------
 -- addkey tests
 -------------------------------------------------------------------------------

 functionsuite:testAddkey()
 suite:assertSortKeyEquals('000000002000-05-27-0003',{2000,5,27,addkey=3})
 suite:assertSortKeyEquals('000000002000-05-27-0003',{2000,5,27,addkey='3'})
 end

 functionsuite:testAddkeyError()
 localmsg="the 'addkey' parameter must be an integer between 0 and 9999"
 self:assertErrorContains(msg,function()
 Dts.new{2000,5,27,addkey=3.5}
 end)
 self:assertErrorContains(msg,function()
 Dts.new{2000,5,27,addkey=-1}
 end)
 self:assertErrorContains(msg,function()
 Dts.new{2000,5,27,addkey=10000}
 end)
 end

 -------------------------------------------------------------------------------
 -- Display tests
 -------------------------------------------------------------------------------

 functionsuite:testFormatDefault()
 suite:assertDisplayEquals('January 27, 2000',{2000,1,27})
 end

 functionsuite:testFormatDMY()
 suite:assertDisplayEquals('27 January 2000',{2000,1,27,format='dmy'})
 end

 functionsuite:testFormatMDY()
 suite:assertDisplayEquals('January 27, 2000',{2000,1,27,format='mdy'})
 end

 functionsuite:testFormatDM()
 suite:assertDisplayEquals('27 January',{2000,1,27,format='dm'})
 end

 functionsuite:testFormatMD()
 suite:assertDisplayEquals('January 27',{2000,1,27,format='md'})
 end

 functionsuite:testFormatMY()
 suite:assertDisplayEquals('January 2000',{2000,1,27,format='my'})
 end

 functionsuite:testFormatY()
 suite:assertDisplayEquals('2000',{2000,1,27,format='y'})
 end

 functionsuite:testFormatM()
 suite:assertDisplayEquals('January',{2000,1,27,format='m'})
 end

 functionsuite:testFormatD()
 suite:assertDisplayEquals('27',{2000,1,27,format='d'})
 end

 functionsuite:testFormatHide()
 suite:assertDisplayEquals('',{2000,1,27,format='hide'})
 end

 functionsuite:testBCParam()
 localresult='January 27, 2000&nbsp;BC'
 suite:assertDisplayEquals(result,{2000,1,27,'BC'})
 suite:assertDisplayEquals(result,{2000,1,27,'BCE'})
 suite:assertDisplayEquals(result,{2000,1,27,'bc'})
 suite:assertDisplayEquals(result,{2000,1,27,'bce'})
 end

 functionsuite:testBCNegativeYear()
 suite:assertDisplayEquals('January 27, 2000&nbsp;BC',{-2000,1,27})
 end

 functionsuite:testLargeYearDisplay()
 suite:assertDisplayEquals('1,000,000',{1000000})
 end

 functionsuite:testLargeNegativeYearDisplay()
 suite:assertDisplayEquals('1,000,000&nbsp;BC',{-1000000})
 end

 -------------------------------------------------------------------------------
 -- Blank tests
 -------------------------------------------------------------------------------

 functionsuite:testBlank()
 self:assertStringContains(
 '^<span data%-sort%-value="[^"<>]-"></span>$',
 mDts._main{}
 )
 end

 -------------------------------------------------------------------------------
 -- Nowrap tests
 -------------------------------------------------------------------------------

 functionsuite:testNoWrapDefault()
 self:assertStringContains(
 self.nowrapPattern,
 mDts._main{2000,1,1}
 )
 end

 functionsuite:testNoWrapOff()
 self:assertStringContainsWhenOff(
 '^<span data%-sort%-value="[^"<>]-">[^>]-</span>$',
 function(off)
 returnmDts._main{2000,1,1,nowrap=off}
 end
 )
 self:assertNotStringContainsWhenOff(
 'white%-space%s*:%s*nowrap',
 function(off)
 returnmDts._main{2000,1,1,nowrap=off}
 end
 )
 end

 functionsuite:testNoWrapOn()
 self:assertStringContainsWhenOn(
 self.nowrapPattern,
 function(on)
 returnmDts._main{2000,1,1,nowrap=on}
 end
 )
 end

 -------------------------------------------------------------------------------
 -- Abbr tests
 -------------------------------------------------------------------------------

 functionsuite:testAbbrDefault()
 self:assertStringContains(
 'January 1, 2000',
 mDts._main{2000,1,1}
 )
 end

 functionsuite:testAbbrOn()
 self:assertStringContainsWhenOn(
 'Jan 1, 2000',
 function(on)
 returnmDts._main{2000,1,1,abbr=on}
 end
 )
 end

 functionsuite:testAbbrOff()
 self:assertStringContainsWhenOff(
 'January 1, 2000',
 function(off)
 returnmDts._main{2000,1,1,abbr=off}
 end
 )
 end

 -------------------------------------------------------------------------------
 -- Main tests
 -------------------------------------------------------------------------------

 functionsuite:testMain()
 localerrorPattern='^<strong class="error">Error in %[%[Template:Date table sorting%]%]: .-</strong>'
 self:assertStringContains(errorPattern,mDts.main{'foo'})
 self:assertNotStringContains(errorPattern,mDts.main{2000})
 self:assertStringContains(errorPattern,mDts._main{'foo'})
 self:assertNotStringContains(errorPattern,mDts._main{2000})
 end

 returnsuite

AltStyle によって変換されたページ (->オリジナル) /