funcs

EPIC IRC客户端。来源于IRCII客户端但做了很多性能和功能的优化。

assert midw(0 1) == []
assert midw(1 1) == []
assert midw(1 -1) == []
assert midw(-1 1) == []
assert midw(0 1 one) == [one]
assert midw(0 1 one two) == [one]
assert midw(1 1 one two) == [two]
assert midw(1 2 one two) == [two]
assert midw(1 -1 one two) == []
assert midw(1 0 one two) == []

# testing $mychannels() -- cant be tested right now
# testing $myservers() -- cant be tested right now
# testing $nametoip() -- cant be tested right now
# testing $nochops() -- cant be tested right now

# testing $notw()
clear
assert notw() == []
assert notw(1) == []
assert notw(-1) == []
assert notw(1 one) == [one]
assert notw(-1 one) == [one]
assert notw(-1 one two) == [one two]
assert notw(1 one two) == [one]
assert notw(0 one two) == [two]
assert notw(3 one two) == [one two]

# testing $numonchannel() -- cant be tested right now.
# testing $onchannel() -- cant be tested right now.

# testing $pattern()
clear
assert pattern() == []
assert pattern(*) == []
assert pattern(* one two) == [one two]
assert pattern(o* one two) == [one]
assert pattern(t* one two) == [two]
assert pattern(r* one two) == []
assert pattern(t* one two three) == [two three]
assert pattern(*e one two three) == [one three]

# testing $pid()
clear
assert pid() != []
assert pid(foo) != []

# testing $push() and $shift()
clear
@ one = []
assert push() == []
assert push(one) == []
assert push(one one) == [one]
assert push(one two) == [one two]
assert push(one three) == [one two three]
assert push(one four) == [one two three four]
clear
assert shift() == []
assert shift(one) == [one]
assert shift(one) == [two]
assert shift(one) == [three]
assert shift(one) == [four]
assert shift(one) == []
assert one == []

# testing $pop(), $unshift()
clear
assert unshift() == []
assert unshift(one) == []
assert unshift(one one) == [one]
assert unshift(one two) == [two one]
assert unshift(one three) == [three two one]
assert unshift(one four) == [four three two one]
assert one == [four three two one]
clear
assert pop() == []
assert pop(one) == [one]
assert pop(one) == [two]
assert pop(one) == [three]
assert pop(one) == [four]
assert pop(one) == []

# testing $ppid()
clear
assert ppid() != []
assert ppid(foo) != []

# testing $prefix()
assert prefix(12345 12340 1234) == [1234]
assert prefix(asdfg asdfx asdf) == [asdf]
assert prefix(ASDFG asdfx asdf) == [ASDF]

# testing $rand() -- cant be tested right now

# testing $remw()
clear
assert remw() == []
assert remw(one) == []
assert remw(one one) == []
assert remw(one two) == [two]
assert remw(one two one three) == [two three]
assert remw(one two three one) == [two three]
assert remw(\\foo foo \\foo \\foo \\foo) == [foo \\foo \\foo]
# remw() tests that failed previously
assert remw(1 11 1) == [11]

# testing $rename() -- cant be tested right now.

# testing $restw()
clear
assert restw() == []
assert restw(1) == []
assert restw(-1) == []
assert restw(1 one) == []
assert restw(-1 one) == []
assert restw(1 one two) == [two]
assert restw(0 one two) == [one two]
assert restw(3 one two) == []

# testing $reverse()
clear
assert reverse() == []
assert reverse(madamimadam) == [madamimadam]
assert reverse(foobar) == [raboof]
assert reverse(one tiny tubesock) == [kcosebut ynit eno]

# testing $revw()
clear
assert revw() == []
assert revw(1) == [1]
assert revw(1 2 3) == [3 2 1]
assert revw("1 2" 3) == [3 "1 2"]

# testing $rfilter()
clear
assert rfilter() == []
assert rfilter(foo) == []
assert rfilter(*) == []
assert rfilter(one o* * *e *t*) == [*t*]
assert rfilter(two o* * *e *t*) == [o* *e]
assert rfilter(foo o* *e *t*) == [o* *e *t*]

# testing $right()
clear
assert right(one) == []
assert right(1 one) == [e]
assert right(2 one) == [ne]
assert right(3 one) == [one]
assert right(4 one) == [one]

# testing $rightw()
clear
assert rightw() == []
assert rightw(0) == []
assert rightw(0 one) == []
assert rightw(-1) == []
assert rightw(-1 one) == []
assert rightw(1) == []
assert rightw(1 one) == [one]
assert rightw(1 one two) == [two]
assert rightw(2) == []
assert rightw(2 one) == [one]
assert rightw(2 one two) == [one two]
assert rightw(2 one two three) == [two three]

# testing $rindex()
clear
assert rindex() == []
assert rindex(/ one) == -1
assert rindex(/ /one) == 0
assert rindex(/ o/ne) == 1
assert rindex(/ on/e) == 2
assert rindex(/ one/) == 3
assert rindex(/ /one/) == 4
assert rindex(^/ ///one/) == 5
assert rindex(the one) == 2
assert rindex(the het) == 2
assert rindex(^the the) == -1
assert rindex(^the one) == 1
assert rindex(^the eon) == 2

# testing $rmatch()
clear
assert rmatch() == []
assert rmatch(one two three) == 0
assert rmatch(two two three) == 1
assert rmatch(three two three) == 2
assert rmatch(one) == 0
assert rmatch(*) == 0
assert rmatch(one *) == 1
assert rmatch(%) == 0
assert rmatch(one %) == 1
assert rmatch(?) == 0
assert rmatch(o ?) == 1
assert rmatch(one ?) == 0
assert rmatch(one ???) == 1
assert rmatch(marble m* n*) == 1
assert rmatch(marble *e *r*b*) == 2
assert rmatch(marble * **) == 1

# testing $rmdir() -- cant be tested right now.

# testing $rpattern()
clear
assert rpattern() == []
assert rpattern(foo) == []
assert rpattern(*) == []
assert rpattern(one o* * *e *t*) == [o* * *e]
assert rpattern(two o* * *e *t*) == [* *t*]
assert rpattern(foo o* *e *t*) == []

# testing $sar()
clear
assert sar() == []
assert sar(/) == []
assert sar(//) == []
assert sar(/one/two/foo one bar) == [foo two bar]
assert sar(/one/two/foo one bar one) == [foo two bar one]
assert sar(g/one/two/foo one bar one) == [foo two bar two]
@ boo = [foo one bar]
assert sar(r/one/two/boo) == [foo two bar]
assert boo == [foo two bar]
@ boo = [foo one bar one]
assert sar(r/one/two/boo) == [foo two bar one]
assert boo == [foo two bar one]
@ boo = [foo one bar one]
assert sar(rg/one/two/boo) == [foo two bar two]
assert boo == [foo two bar two]

# testing $splice() 
clear
@ boo = [foo one bar one]
assert splice(boo 1 2 booya booya) == [one bar]
assert splice(boo 0 3 blah1) == [foo booya booya]
assert splice(boo 3 0 blah2) == []
assert splice(boo 4 1 blah3) == []
assert splice(boo -1 3 blah4) == [blah1 one]
assert splice(boo 0 0 blah5) == []
assert boo == [blah5 blah4 blah2 blah3]

# testing $split()
clear
assert split() == []
assert split(#) == []
assert split(# one) == [one]
assert split(# one##two) == [one  two]
assert split(# one##two##) == [one  two  ]

# testing $srand() -- cant be tested right now

# testing $time() and $stime()
clear
assert time() != []
assert time(FOO) != []
assert stime() == []
assert stime($time()) != []

# testing $strip()
clear
assert strip() == []
assert strip(~) == []
assert strip(~ ~) == []
assert strip(~ ~~) == []
assert strip(~ ~ ~) == [ ]
assert strip(~ ~one t~o th~ree) == [one to three]
assert strip(~ one two three) == [one two three]
assert strip(~ ~on~ ~tw= thre~==) == [on tw= thre==]

# testing $tdiff()
clear
assert tdiff() == []
assert tdiff(3663) == [1 hour 1 minute 3 seconds]
assert tdiff(60) == [1 minute]
assert tdiff(0) == [0 seconds]

# testing $tolower()
clear
assert tolower() == []
assert tolower(one two three) == [one two three]
assert tolower(ONE TWO THREE) == [one two three]
assert tolower(oNe TwO tHrEe) == [one two three]
assert tolower(one @#\$ t\$r!e) == [one @#\$ t\$r!e]

# testing $toupper()
clear
assert toupper() == []
assert toupper(one two three) == [ONE TWO THREE]
assert toupper(ONE TWO THREE) == [ONE TWO THREE]
assert toupper(oNe TwO tHrEe) == [ONE TWO THREE]
assert toupper(one @#\$ t\$r!e) == [ONE @#\$ T\$R!E]

# testing $tow()
clear
assert tow() == []
assert tow(one) == []
assert tow(one two) == []
assert tow(one two three one four five) == [two three one]
assert tow(two two three four five two) == [two]
assert tow(one one) == [one]
assert tow(one three four five) == []

# testing $tr()
clear
assert tr() == []
assert tr(/abc/def/Mary had a little lamb) == [Mdry hdd d little ldme]
assert tr(/abc//Mary had a little lamb) == [Mry hd  little lm]
assert tr(/abc/d/Mary had a little lamb) == [Mdry hdd d little ldmd]

# testing $trunc()
#XXX NEEDS TEST

# testing $unlink() -- cant be tested right now
# testing $userhost() -- cant be tested right now
# testing $version() -- cant be tested right now
# testing $which() -- cant be tested right now
# testing $winnam() -- cant be tested right now
# testing $winnum() -- cant be tested right now

# testing $word()
clear
assert word() == []
assert word(1) == []
assert word(0 one) == [one]
assert word(1 one) == []
assert word(1  one two) == [two]
assert word(2  one two three four five) == [three]

# testing $open(), $read() $write() $close()
assert (::rfd = open(/dev/zero r)) >= 3
assert (::wfd = open(/dev/zero w)) >= 4
assert writeb($wfd $read($rfd 100000)) == 100000
assert write($wfd $read($rfd 100000)) == 200001
assert close($rfd) == 0
assert close($rfd) == -1
assert close($wfd) == 0
assert close($wfd) == -1

# Testing Karll Arrays.
#XXX Incomplete.
clear
assert delarray(testarray) <= 0
assert setitem(testarray 0 3) == 1
assert setitem(testarray 1 2) == 2
assert setitem(testarray 2 1) == 2
assert setitem(testarray 3 0) == 2
assert numitems(testarray) == 4
assert getitem(testarray 0 1 2 3) == [3 2 1 0]
assert igetitem(testarray 0 1 2 3) == [0 1 2 3]
assert itemtoindex(testarray 0 1 2 3) == [3 2 1 0]
assert indextoitem(testarray 0 1 2 3) == [3 2 1 0]
assert delitem(testarray 3) == 0
assert delitem(testarray 3) == -2
assert delitem(testarray 1) == 0
assert delarray(testarray) == 0
assert delarray(testarray) == -1

# Testing internal array consistency.
echo
fe (function fnexist command cexist set) label exist {
	@ :last = []
	@ :array = [get${label}s]
	echo Checking $label array consistency.
	fe ( ${ [$array]() } ) fn {
		if ( sort($last $fn) != uniq($last $fn) ) {
			echo ${label}s $last and $fn are not in the correct order.
		} elsif ( exist && ![$exist]($fn) ) {
			echo Can't find $label $fn
		}
		@ :last = fn
	}
}

# Check whether documentation exists.
echo
if (fexist($getset(help_path))) {
	fe (function 6* command [1-5]* set 4*/set*) type section {
		@ :list = [get${type}s]()
		@ :list = tolower($list)
		@ :section = [$getset(help_path)/$section]
		fe list item {
			@ item = 0 < fsize($globi($section/$item)) ? [] : item
		}
		if (#list) {
			echo Undocumented ${type}s: $list
		}
	}
} else {
	echo Skipping documentation test since no documentation was found.
}

echo
echo
echo
echo ALL TESTS ARE DONE!