github/atom
1
1
Fork 0
mirror of https://github.com/atom/atom.git synced 2026-02-12 23:55:10 -05:00
Code Issues Packages Projects Releases Wiki Activity
Files
e9cefaac5ef879eb3fa85b3be68259aa68fe866b
atom/bundles/ruby.tmbundle/Tests/rubylexer/regtest.rb
Corey Johnson & Nathan Sobo f84f9c5dd2 Add bundles and themes
2012-08-27 13:20:22 -07:00

622 lines
21 KiB
Ruby
Raw Blame History

#!/usr/bin/ruby -w -d
require "reg"
require "regarray"
require "reglogic"
require "reghash"
require "regvar"
require "assert"
require 'getoptlong'
#require 'test/unit'
class TC_Reg #< Test::Unit::TestCase
class <<self
def randsym
as=Symbol.all_symbols
as[rand as.size]
end
def makelendata(num=20,mask=0b11111111111,mischief=false)
result=[]
(1..num).each do
begin type=rand(11) end until 0 != mask&(1<<type)
len=type==0 ? 0 : rand(4)
result<<case type
when 0 then [0]
when 1 then [len]+(1..len).map{randsym}
when 2 then (1..len).map{randsym}+[-len]
when 3 then (1..len).map{randsym}+["infix#{len}"]+(1..len).map{randsym}
when 4
[:Q] +
(1..len).map{randsym}.delete_if {|x|:Q==x} +
(1..rand(4)).map{randsym}.delete_if {|x|:Q==x} +
[:Q]
when 5
[:Q] +
(1..len).map{randsym}.delete_if {|x|:Q==x} +
[:'\\', :Q] +
(1..rand(4)).map{randsym}.delete_if {|x|:Q==x} +
[:Q]
when 6
[:q]+(1..len).map{randsym}.delete_if {|x|:q==x}+[:q]
when 7
[:begin]+
(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
(1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:end]
when 8
[:begin]+
(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:'\\', 0==rand(1) ? :begin : :end] +
(1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:end]
when 9
[:begin]+
(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:begin]+(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +[:end]+
(1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:end]
when 10
[:begin]+
(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:'\\', 0==rand(1)? :begin : :end] +
(1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:begin]+(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +[:end]+
(1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
[:end]
end
end
mischief and result.insert(rand(result.size),mischief)
return result
end
def test_reg
lenheadalts=-[0]|-[1,OB]|-[2,OB*2]|-[3,OB*3]|-[4,OB*4]
lenheadlist=lenheadalts+1
lenheaddata=[0,0,0,1,:foo,4,:foo,:bar,:baz,:zork,3,:k,77,88]
lenheaddataj=lenheaddata+[:j]
#not used yet:
lentailalts=-[OB,-1]|-[OB*2,-2]|-[OB*3,-3]|-[OB*4,-4]
lentaildata=lenheaddata.reverse.map {|x| Integer===x ? -x : x }
infixalts=-[OB,"infix1",OB]|-[OB*2,'infix2',OB*2]|
-[OB*3,'infix3',OB*3]|-[OB*4,'infix4',OB*4]
qq=-[:q, ~(:q.reg)+0, :q]
_QQ=-[:Q, ( ~/^[Q\\]$/.sym | -[:'\\',OB] )+0, :Q]
be=-[:begin, (
~/^(begin|end|\\)$/.sym |
-[:'\\',OB] |
innerbe=Reg.const
)+0, :end]
innerbe.set! be
lh_or_qq=lenheadalts|qq|_QQ
lhqqbe=lh_or_qq|be
#broken:
#eat_unworking=<<'#end unworking'
a=[:foo]*4
x=(OB*2*(1..2)).mmatch(a,2)
assert x.next_match(a,2)==[[[[:foo, :foo]]], 2]
assert x.next_match(a,2)==nil
assert_eee OB*(1..2)*2,[:foo]*2
a=[:foo]*3
x=(OB*(1..2)*2).mmatch(a,0)
assert x.next_match(a,0)==
[[ [[:foo, :foo]], [[:foo]] ], 3]
assert x.next_match(a,0)==
[[ [[:foo]], [[:foo, :foo]] ], 3]
assert x.next_match(a,0)==
[[ [[:foo]], [[:foo]] ], 2]
assert x.next_match(a,0).nil?
a=[:foo]*6
x=(OB*2*(1..2)*2).mmatch(a,0)
assert x.next_match(a,0)==
[[ [[[:foo, :foo]], [[:foo, :foo]]], [[[:foo, :foo]]] ], 6]
assert x.next_match(a,0)==
[[ [[[:foo, :foo]]], [[[:foo, :foo]], [[:foo, :foo]]] ], 6]
assert x.next_match(a,0)==
[[ [[[:foo, :foo]]], [[[:foo, :foo]]] ], 4]
assert x.next_match(a,0).nil?
$RegTraceEnable=true
assert_eee Reg[OB*2*(1..2)*2], [:foo]*6
assert_eee Reg[OB*2*(1..2)*2, OB-1], [:foo]*7
assert_eee Reg[OB*2*(1..2)*2], [:foo]*8
assert_eee Reg[OB*2*(1..2)*2], [:foo]*4
assert_eee Reg[OB*(2..3)*(1..2)*2], [:foo]*4
assert_eee Reg[OB*(2..3)*(2..3)*(1..2)], [:foo]*4
assert_eee Reg[OB*(2..2)*(2..3)*(2..3)], [:foo]*8
assert_eee Reg[OB*(2..3)*(2..2)*(2..3)], [:foo]*8
assert_eee Reg[OB*(2..3)*(2..3)*2], [:foo]*8
assert_eee Reg[OB*(2..3)*(2..3)*(2..3)], [:foo]*8
assert_eee Reg[OB+2+2+2], [:foo]*8
assert_eee Reg[OB+2+2+2], [:foo]*9
assert_ene Reg[:foo.reg*(2..3)*(2..3)*2], [:foo]*7
assert(!(Reg[OB*1*(1..2)]===[:f]).first.empty?)
#btracing monsters
0.upto(5) {|i|
assert_ene Reg[OB+1+3+2], [:f]*i }
6.upto(16){|i| assert_eee Reg[OB+1+3+2], [:f]*i }
assert_ene Reg[OB+2+3+2], [:f]*11
assert_eee Reg[OB+2+3+2], [:f]*12
assert_ene Reg[OB+2+3+3], [:f]*17
assert_eee Reg[OB+2+3+3], [:f]*18
assert_ene Reg[OB+3+3+3], [:f]*26
assert_eee Reg[OB+3+3+3], [:f]*27
assert_ene Reg[OB+4+4+4], [:f]*63
assert_eee Reg[OB+4+4+4], [:f]*64
assert_ene Reg[OB+2+2+2+2], [:f]*15
assert_eee Reg[OB+2+2+2+2], [:f]*16
assert_ene Reg[OB+2+2+2+2+2+2+2+2], [:foo]*255
assert_eee Reg[OB+2+2+2+2+2+2+2+2], [:foo]*256
aaa_patho=+[-[/^a/]|-[/^.a/, OB]|-[/^..a/, OB*2]]
assert_eee aaa_patho, ["aaa"]*200
assert_ene Reg[OB+1+2+2], [:f]*3
assert_ene Reg[OB+2+1+2], [:f]*3
assert_eee Reg[OB+2+1+2], [:f]*4
assert_ene Reg[OB+2+2+2], [:f]*7
assert_eee Reg[OB+2+2+2], [:f]*8
assert_ene Reg[OB+2+2+3], [:f]*11
assert_eee Reg[OB+2+2+3], [:f]*12
assert_eee Reg[OB+2+2+3], [:f]*16
assert_ene Reg[5.reg+1+3+2], [6]+[5]*5
assert_ene Reg[5.reg+1+3+2], [5]+[6]+[5]*4
assert_ene Reg[5.reg+1+3+2], [5]*2+[6]+[5]*3
assert_ene Reg[5.reg+1+3+2], [5]*3+[6]+[5]*2
assert_ene Reg[5.reg+1+3+2], [5]*4+[6,5]
assert_ene Reg[5.reg+1+3+2], [5]*5+[6]
assert_ene Reg[OB+1+3+2], [6]+[5]*5
assert_ene Reg[OB+1+3+2], [5]+[6]+[5]*4
assert_ene Reg[OB+1+3+2], [5]*2+[6]+[5]*3
assert_ene Reg[OB+1+3+2], [5]*3+[6]+[5]*2
assert_ene Reg[OB+1+3+2], [5]*4+[6,5]
assert_ene Reg[OB+1+3+2], [5]*5+[6]
assert_eee Reg[5.reg+1+3+2], [5]*6
assert_ene Reg[5.reg+2+2+2], [5]*8+[6]
#end unworking
#working:
assert_ene Reg[OB*(2..2)*(2..3)*(2..3)], [:foo]*7
assert_ene Reg[OB*(2..3)*(2..2)*(2..3)], [:foo]*7
assert_ene Reg[OB*(1..3)*(2..3)*2], [:foo]*3
assert_ene Reg[OB*(2..3)*(1..3)*2], [:foo]*3
assert_ene Reg[OB*(2..3)*(2..3)*(1..2)], [:foo]*3
assert_ene Reg[OB*(2..3)*(2..3)*2], [:foo]*7
assert_ene Reg[OB*(2..3)*(2..3)*(2..3)], [:foo]*7
assert_ene Reg[OB+2+2+2], [:foo]*7
assert_eee Reg[OB*(1..3)*(2..3)*2], [:foo]*4
assert_eee Reg[OB*2*1*2], [:foo]*4
assert_eee Reg[OB*1*(1..2)*2], [:foo]*2
assert_eee Reg[OB*2*(1..2)*1], [:foo]*2
assert_eee Reg[OB*1*(1..2)*2], [:foo]*3
assert_ene Reg[OB*2*(1..2)*1], [:foo]*3
assert_eee Reg[OB*1*(1..2)*2], [:foo]*4
assert_eee Reg[OB*2*(1..2)*1], [:foo]*4
a=[:foo]
x=(:foo.reg-1).mmatch a,0
assert x.next_match(a,0)==[[[:foo]],1]
assert x.next_match(a,0)==[[[]],0]
assert x.next_match(a,0)==nil
x=(:foo.reg-1).mmatch a,1
assert x==[[[]],0]
a=[:foo]
x=(:foo.reg-1-1).mmatch a,0
assert x.next_match(a,0)==[[[[:foo]]],1]
a=[:foo]*3
x=(:foo.reg*(1..2)).mmatch a,0
assert x.next_match(a,0)==[[[:foo]*2],2]
assert x.next_match(a,0)==[[[:foo]],1]
assert x.next_match(a,0)==nil
x=(:foo.reg*(1..2)).mmatch a,1
assert x.next_match(a,0)==[[[:foo]*2],2]
assert x.next_match(a,0)==[[[:foo]],1]
assert x.next_match(a,0)==nil
x=(:foo.reg*(1..2)).mmatch a,2
assert x==[[[:foo]],1]
x=(:foo.reg*(1..2)).mmatch a,3
assert x.nil?
x=(:foo.reg*(1..2)*(2..3)).mmatch a,0
assert x.next_match(a,0)==[[[[:foo]*2],[[:foo]]], 3]
assert x.instance_eval{@ri}==2
assert x.next_match(a,0)==[[[[:foo]],[[:foo]*2]], 3]
assert x.instance_eval{@ri}==2
assert x.next_match(a,0)==[[[[:foo]],[[:foo]],[[:foo]]], 3]
assert x.instance_eval{@ri}==3
assert x.next_match(a,0)==[[[[:foo]],[[:foo]]], 2]
assert x.instance_eval{@ri}==2
assert x.next_match(a,0)==nil
x=(:foo.reg*(1..2)*(2..3)).mmatch a,1
assert x.next_match(a,0)==[[[[:foo]],[[:foo]]], 2]
assert x.instance_eval{@ri}==2
assert x.next_match(a,0)==nil
x=(:foo.reg*(1..2)*(2..3)).mmatch a,2
assert x.nil?
x=(:foo.reg*(1..2)*(2..3)).mmatch a,3
assert x.nil?
assert((not (:foo.reg*(1..2)*(2..3)*(2..3)).mmatch [:foo]*3,0 ))
assert_ene Reg[:foo.reg*(1..2)*(2..3)*(2..3)], [:foo]*3
assert_eee Reg[:foo.reg*(1..2)*(2..3)*(2..3)], [:foo]*4
assert_ene Reg[OB*(1..2)*(2..3)*(2..3)], [:foo]*3
assert_eee Reg[OB*(1..2)*(2..3)*(2..3)], [:foo]*4
assert_ene Reg[OB*(1..2)*(2..3)+2], [:foo]*3
assert_eee Reg[OB*(1..2)*(2..3)+2], [:foo]*4
assert_ene Reg[OB*(1..2)+2+2], [:foo]*3
assert_eee Reg[OB*(1..2)+2+2], [:foo]*4
assert_ene Reg[OB+1+2+2], [:foo]*3
assert_eee Reg[OB+1+2+2], [:foo]*4
assert_eee Reg[5.reg+2+2], [5]*4
assert_eee Reg[5.reg*(1..2)*(1..2)*(1..2)], [5]
assert_eee Reg[5.reg*(1..2)*(1..2)*(2..3)], [5]*2
assert_eee Reg[5.reg*(1..2)*(2..3)*(2..3)], [5]*4
assert_eee Reg[(5.reg+1)*(2..3)*(2..3)], [5]*4
assert_eee Reg[(5.reg+1+2)*(2..3)], [5]*4
assert_eee Reg[5.reg+1+2+2], [5]*4
assert_eee Reg[OB+3+2], [:f]*6
assert_ene Reg[-[:foo,:bar]-1], [:bar,:foo]
assert_ene Reg[-[:foo,:bar]-1], [:baz,:foo,:bar]
assert_ene Reg[-[:foo,:bar]-1], [:foo,:bar,:baz]
assert_eee Reg[-[:foo,:bar]-1], [:foo,:bar]
assert_ene Reg[-[:foo,:bar]-1], [:foo]
assert_ene Reg[-[:foo,:bar]-1], [:bar]
assert_ene Reg[-[:foo,:bar]-1], [:baz]
assert_eee Reg[-[:foo,:bar]-1], []
assert_eee Reg[(-[-[:p]*(1..2)])], [:p]
assert_eee Reg[(-[-[:p]*(1..2)])], [:p,:p]
assert_ene Reg[(-[-[:p]*(1..2)])], [:p,:q]
assert_ene Reg[(-[-[:p]*(1..2)])], [:q]
assert_ene Reg[(-[-[:p]*(1..2)])], []
assert_ene Reg[(-[-[:p]*(1..2)])], [:p,:p, :p]
assert_eee Reg[OB+1], [:foo,:foo]
assert_eee Reg[OB+1+1], [:foo,:foo]
assert_eee Reg[OB+1+1+1], [:foo,:foo]
assert_eee Reg[OB+1+1+1+1], [:foo,:foo]
assert_ene Reg[OB+2+3], [:f]*5
assert_ene Reg[OB+2+2+1], [:f]*3
assert_eee Reg[lhqqbe+0], [
:begin, :popen, :"chomp!", :-@, :end, :q, :q,
:begin, :begin, :end, :end,
:begin, :MINOR_VERSION, :"public_method_defined?", :"\\", :begin, :umask,
:debug_print_help, :geteuid, :end,
:q, :public_methods, :option_name, :MUTEX, :q,
:begin, :verbose=, :binding, :symlink, :lambda,
:emacs_editing_mode, :"dst?", :end, 0,
:begin, :test_to_s_with_iv, :"\\", :begin, :glob, :each_with_index,
:initialize_copy, :begin, :$PROGRAM_NAME, :end,
:ELIBACC, :setruid, :"success?", :end,
:begin, :__size__, :width, :"\\", :begin, :$-a, :"sort!", :waitpid, :end,
:begin, :Stat, :WadlerExample, :chr, :end,
:begin, :+, :disable, :abstract,
:begin, :__size__, :"symlink?", :"dst?", :end, :ljust, :end,
:begin, :debug_method_info, :matchary, :"\\", :begin, :ftype,
:thread_list_all, :eof, :begin, :abs, :GroupQueue, :end,
:"slice!", :ordering=, :end,
:Q, :"\\", :Q, :ELIBMAX, :GetoptLong, :nlink, :Q,
:begin, :Fixnum, :waitall, :"enclosed?", :"\\", :begin, :deep_copy,
:getpgid, :strftime, :end,
:Q, :close_obj, :Q,
3, :basic_quote_characters=, :rmdir, :"writable_real?",
:begin, :test_hello_11_12, :utc_offset, :freeze,
:begin, :kcode, :egid=, :ARGF, :end,
:setuid, :lock, :gmtoff, :end,
:begin, :$FILENAME, :test_tree_alt_20_49,
:begin, :LOCK_SH, :EL3HLT, :end, :end,
:Q, :"\\", :Q, :ceil, :remainder, :group_sub, :Q, 0
]
if ($Slow||=nil)
#assert_eee Reg[OB+10+10], [:f]*100 #waaaay too slow
assert_eee Reg[OB+5+5], [:f]*25
assert_ene Reg[OB+5+5], [:f]*24
assert_eee Reg[OB+6+6], [:f]*36
assert_ene Reg[OB+6+6], [:f]*35
assert_eee Reg[OB+7+7], [:f]*49 #prolly excessive
assert_ene Reg[OB+7+7], [:f]*48 #prolly excessive
end
assert_eee Reg[lhqqbe+0], [ :begin, :"\\", :rand, :end ]
#breakpoint
assert_eee +[be], [:begin, :"\\", :"\\", :end]
assert_eee +[be], [:begin, :"\\", :begin, :end]
assert_eee +[be], [:begin, :"\\", :end, :end]
assert_eee +[be], [:begin, :log, :readline, :"\\", :begin, :lh_or_qq, :test_pretty_print_inspect, :@newline, :end]
assert_eee +[be], [:begin, :lock, :rindex, :begin, :sysopen, :rename, :end, :re_exchange, :on, :end]
assert_eee +[be], [:begin, :lock, :"\\", :"\\", :begin, :rename, :end, :on, :end]
assert_eee +[be], [:begin, :begin, :foo, :end, :end]
assert_eee +[be], makelendata(1,0b11110000000).flatten
assert_eee +[be], [:begin, :end]
assert_eee +[be], [:begin, :foo, :end]
assert_eee +[be], makelendata(1,0b10000000).flatten
assert_eee Reg[lhqqbe+0], makelendata(1,0b11111110011).flatten
assert_eee Reg[lhqqbe+0], makelendata(4,0b11111110011).flatten
assert_eee Reg[lhqqbe+0], makelendata(10,0b11111110011).flatten
assert_eee Reg[lhqqbe+0], makelendata(20,0b11111110011).flatten
assert_ene Reg[:foo,OB+1], [:foo]
assert_ene Reg[OB+1,:foo], [:foo]
assert_eee Reg[OB+1], [:foo]
assert_eee Reg[OB+1+1+1+1+1+1+1+1+1+1+1+1+1+1], [:foo]
assert_ene Reg[OB+1+1+1+1], []
assert_eee Reg[OB+1+1+1+1], [:foo,:foo]
assert_ene Reg[OB+2], [:foo]
assert_ene Reg[OB+2+2], [:foo]*3
assert_ene Reg[OB+2+2+1], [:foo]*3
assert_ene Reg[OB+2+1+2], [:foo]*3
assert_eee Reg[-[1,2]|3], [1,2]
assert_eee Reg[-[1,2]|3], [3]
assert_ene Reg[-[1,2]|3], [4]
assert_ene Reg[-[1,2]|3], [2]
assert_ene Reg[-[1,2]|3], [1,3]
assert_eee Reg[lenheadlist], [1, :__id__]
assert_eee Reg[(-[0]|-[1,OB]|-[2,OB*2])*1], [2, :p, :stat]
assert_eee Reg[(-[2,OB*2])-1], [2, :p, :stat]
assert_eee Reg[(-[OB])*(1..2)], [1, :p]
assert_eee Reg[(-[-[:p]*(1..2)])], [:p]
assert_eee Reg[(-[-[:p]])*(1..2)], [:p]
assert_eee Reg[(-[-[OB]])*(1..2)], [:p]
assert_eee Reg[(-[OB*1])*(1..2)], [:p]
assert_eee Reg[(-[1,OB*1])*(1..2)], [1, :p]
assert_eee Reg[(-[2,OB*2])*(1..2)], [2, :p, :stat]
assert_eee Reg[(-[0]|-[1,OB]|-[2,OB*2])*(1..2)], [2, :p, :stat]
assert_eee Reg[(-[0]|-[1,OB]|-[2,OB*2])+1], [2, :p, :stat]
assert_eee Reg[lenheadlist], [2, :p, :stat]
assert_eee Reg[lenheadlist], [2, :p, :stat, 1, :__id__]
assert_eee Reg[lenheadlist], [2, :p, :stat, 0, 1, :__id__, 0, 0]
assert_eee Reg[lenheadlist], lenheaddata
assert_ene Reg[lenheadlist], lenheaddataj
assert_eee +[lh_or_qq+0], lenheaddata
assert_eee +[lh_or_qq+0], lenheaddata+[:q, :foo, :bar, :baz, :q]
assert_eee Reg[lenheadlist], [0]
assert_eee Reg[lenheadlist], makelendata(1,0b11).flatten
assert_eee Reg[lenheadlist], makelendata(5,0b11).flatten
assert_eee Reg[lenheadlist], makelendata(10,0b11).flatten
assert_eee Reg[lenheadlist], makelendata(20,0b11).flatten
assert_ene Reg[lenheadlist], makelendata(20,0b11).flatten+[:j]
assert_ene Reg[lenheadlist], [:j]+makelendata(20,0b11).flatten+[:j]
assert_ene Reg[lenheadlist], [:j]+makelendata(20,0b11).flatten
assert_ene Reg[lenheadlist], makelendata(20,0b11,:j).flatten
assert_eee +[lh_or_qq+0], makelendata(20,0b11).flatten
assert_eee +[lh_or_qq+0], makelendata(20,0b1000011).flatten
assert_ene +[lh_or_qq+0], makelendata(20,0b1000011).flatten+[:j]
assert_ene +[lh_or_qq+0], [:j]+makelendata(20,0b1000011).flatten+[:j]
assert_ene +[lh_or_qq+0], [:j]+makelendata(20,0b1000011).flatten
t=(1..2)
assert_eee Reg[OB*t*t*t*t], [:foo]*16
assert_ene Reg[OB*t*t*t*t], [:foo]*17
assert_eee Reg[5.reg*t], [5]
assert_eee Reg[5.reg*t*1], [5]
assert_eee Reg[5.reg*1*t], [5]
assert_eee Reg[5.reg*t*t], [5]
assert_eee Reg[5.reg*t*t*t], [5]
assert_eee Reg[5.reg*t*t*t*t], [5]
assert_eee Reg[5.reg+1+1+1], [5]
assert_eee Reg[5.reg+1+1+1+1], [5]
assert_eee Reg[OB+1+1+1], [:foo]
assert_eee Reg[OB+1+1+1+1], [:foo]
assert_eee Reg[OB+2], [:foo]*2
assert_eee Reg[OB+2+2], [:foo]*4
#btracing monsters:
assert_eee Reg[OB*2], [:foo]*2
assert_eee Reg[OB*2*2], [:foo]*4
assert_eee Reg[OB*2*2*2*2], [:foo]*16
assert_eee Reg[OB*2*2*2*2*2*2*2*2], [:foo]*256
assert_eee Reg[OB-2-2-2-2-2-2-2-2], [:foo]*256
assert_ene Reg[OB-0], [1]
assert_eee Reg[OB+0], [1]
assert_eee Reg[OB-1], [1]
assert_eee Reg[OB+1], [1]
assert_eee Reg[OB-2], [1,2]
assert_eee Reg[OB+2], [1,2]
assert_eee Reg[OB], [1]
assert_eee Reg[OB*1], [1]
assert_eee Reg[OB*2], [1,2]
assert_eee Reg[OB*4], [1,2,3,4]
abcreg=Reg[OBS,:a,:b,:c,OBS]
assert_eee abcreg, [:a,:b,:c,7,8,9]
assert_eee abcreg, [1,2,3,:a,:b,:c,7,8,9]
assert_eee abcreg, [1,2,3,:a,:b,:c]
assert_eee abcreg, [:a,:b,:c]
assert_ene abcreg, [1,2,3,:a,:b,:d]
assert_ene abcreg, [1,2,3,:a,:d,:c]
assert_ene abcreg, [1,2,3,:d,:b,:c]
assert_ene abcreg, [1,2,3]
assert_ene abcreg, [1,2,3,:a]
assert_ene abcreg, [1,2,3,:a,:b]
assert_eee Reg[:a, OB+0, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
assert_eee Reg[:a, OB+0, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
assert_eee Reg[:a, OB+0, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
assert_eee Reg[:a, OB+1, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
assert_eee Reg[:a, OB+1, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
assert_ene Reg[:a, OB+1, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
assert_ene Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
assert_eee Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
assert_eee Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
assert_ene Reg[:a, OB-0, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
assert_ene Reg[:a, OB-0, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
assert_eee Reg[:a, OB-0, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
assert_eee Reg[-[OB*2]], [99, 99] #di not right in top level
assert_eee Reg[-[-[-[-[-[OB*2]]]]]], [99, 99] #di not right in top level?
assert_eee Reg[-[-[-[-[-[OB*1]]]]]], [99] #di not right in top level?
#RR[RR[[RR[RR[RR[RR[99,99]]]]]]]
assert_eee Reg[OB*1], [:foo]
assert_eee Reg[-[OB]], [88]
assert_ene Reg[-[0]], [88]
assert_eee Reg[-[0]], [0]
assert_eee Reg[-[OB*1]], [:foo]
assert_eee Reg[OB*1*1], [:foo]
assert_eee Reg[OB*1*1*1*1*1*1*1*1*1*1*1*1*1*1], [:foo]
assert_eee Reg[OB-1-1-1-1-1-1-1-1-1-1-1-1-1-1], [:foo]
assert_eee Reg[-[2,OB*2]], [2, 99, 99]
assert_eee RegMultiple, -[0]|-[1,2]
assert( (-[0]|-[1,2]).respond_to?( :mmatch))
assert_eee Reg[-[0],OBS], lenheaddataj
assert_eee Reg[-[0]|-[1,OB],OBS], lenheaddataj
assert_eee Reg[-[0]|-[1,OB]|-[2,OB*2],OBS], lenheaddataj
assert_eee Reg[-[0]|-[1,OB]|-[2,OB*2]|-[3,OB*3],OBS], lenheaddataj
assert_eee Reg[-[0]|-[1,OB]|-[2,OB*2]|-[3,OB*3]|-[4,OB*4],OBS], lenheaddataj
assert_eee Reg(:a=>:b), {:a=>:b} #=> true
assert_ene Reg(:a=>:b), {:a=>:c} #=> false
assert_ene Reg(:a=>:b), {} #=> false
h={}
h.default=:b
assert_eee Reg(:a=>:b), h #=> true
assert_eee Reg(/^(a|b)$/=>33), {"a"=>33} #=> true
assert_eee Reg(/^(a|b)$/=>33), {"b"=>33} #=> true
assert_ene Reg(/^(a|b)$/=>33), {"a"=>133} #=> false
assert_ene Reg(/^(a|b)$/=>33), {"b"=>133} #=> false
assert_ene Reg(/^(a|b)$/=>33), {"c"=>33} #=> false
assert_eee Reg(/^(a|b)$/=>33), {"a"=>33,"b"=>33} #=> true
assert_ene Reg(/^(a|b)$/=>33), {"a"=>33,"b"=>133} #=> false
assert_ene Reg(/^(a|b)$/=>33), {"a"=>133,"b"=>33} #=> false
assert_ene Reg(/^(a|b)$/=>33), {"a"=>133,"b"=>133} #=> false
assert_eee Reg("a"=>33)|{"b"=>33}, {"a"=>33,"b"=>33} #=> true
assert_eee Reg("a"=>33)|{"b"=>33}, {"a"=>33,"b"=>133} #=> true
assert_ene Reg("a"=>33)|{"b"=>33}, {"a"=>133,"b"=>33} #=> false
assert_ene Reg("a"=>33)|{"b"=>33}, {"a"=>133,"b"=>133} #=> false
assert_eee Reg("a"=>33)|{"b"=>33}, {"b"=>33} #=> true
assert_eee Reg(:a.reg|:b => 44), {:a => 44} #=> true
assert_eee Reg(:a.reg|:b => 44), {:b => 44} #=> true
assert_ene Reg(:a.reg|:b => 44), {:a => 144} #=> false
assert_ene Reg(:a.reg|:b => 44), {:b => 144} #=> false
print "\n"
end
def assert_eee(left,right,message='assert_eee failed')
assert(
left===right,
message+" left=#{left.inspect} right=#{right.inspect}"
)
print ".";$stdout.flush
end
def assert_ene(left,right,message='assert_ene failed')
assert(
!(left===right),
message+" left=#{left.inspect} right=#{right.inspect}"
)
print ",";$stdout.flush
end
end
end
srand;seed=srand
opts=GetoptLong.new(["--seed", "-s", GetoptLong::REQUIRED_ARGUMENT])
opts.each{|opt,arg|
opt=='--seed' or raise :impossible
seed=arg
}
print "random seed is #{seed}\n"
srand seed
TC_Reg.test_reg
Reference in New Issue View Git Blame Copy Permalink