ruby-x/rubyx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix comparison test and helpers

Browse Source 
moving to passing the instruction number, not the instruction
so in the error message we can say where the error is
(otherwise minitest is good enough to supress the trace of asserts calling asserts)
This commit is contained in:
Torsten
2020-03-06 21:26:23 +02:00
parent 3575aada17
commit 1760b5b203
4 changed files with 132 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
test/support/risc_assert.rb
View File

@ -3,91 +3,122 @@ module Minitest
def assert_tos string , object
assert_equal string , object.to_s.gsub("\n",";").gsub(/\s+/," ").gsub("; ",";")
end
def assert_register( kind , pattern , register)
def assert_register( kind , pattern , register , at = 0)
return unless register
if(pattern.is_a?(Symbol))
assert_equal( pattern , register.symbol , "wrong #{kind} register:#{register}")
assert_equal( pattern , register.symbol , "wrong #{kind} register:#{register} , at:#{at}")
else
is_parts = pattern.split(".")
reg_parts = register.symbol.to_s.split(".")
assert_equal reg_parts.length , is_parts.length , "wrong dot length for #{pattern}"
assert_equal reg_parts.length , is_parts.length , "wrong dot length for #{pattern} , at:#{at}"
is_parts.each_with_index do |part , index|
assert reg_parts[index].start_with?(part) , "wrong #{kind}, at:#{part} register:#{register}"
assert reg_parts[index].start_with?(part) , "wrong #{kind}, part:#{part} register:#{register}, at:#{at}"
end
end
end
def assert_slot_to_reg( slot , array = nil, index = nil , register = nil)
assert_equal Risc::SlotToReg , slot.class
assert_register( :source , array , slot.array)
assert_register( :destination , register , slot.register )
assert_index( :source , slot , index)
def assert_slot_to_reg( slot_i , array = nil, index = nil , register = nil)
assert_equal Integer , slot_i.class , "assert_slot_to_reg #{slot_i}"
slot = risc(slot_i)
assert_equal Risc::SlotToReg , slot.class , "Class at #{slot_i}"
assert_register( :source , array , slot.array , slot_i)
assert_register( :destination , register , slot.register , slot_i )
assert_index( :source , slot_i , index)
end
def assert_reg_to_slot( slot , register = nil, array = nil, index = nil )
assert_equal Risc::RegToSlot , slot.class
assert_register( :source , register , slot.register )
assert_register( :destination , array , slot.array)
assert_index( :destination , slot , index)
def assert_reg_to_slot( slot_i , register = nil, array = nil, index = nil )
assert_equal Integer , slot_i.class, "assert_reg_to_slot #{slot_i}"
slot = risc(slot_i)
assert_equal Risc::RegToSlot , slot.class, "Class at #{slot_i}"
assert_register( :source , register , slot.register , slot_i)
assert_register( :destination , array , slot.array , slot_i)
assert_index( :destination , slot_i , index )
end
def assert_index(kind , slot , index)
def assert_index(kind , slot_i , index)
return unless index
assert_equal Integer , slot_i.class , "assert_index #{slot_i}"
slot = risc(slot_i)
if(slot.index.is_a?(Risc::RegisterValue))
assert_equal( Symbol , index.class, "wrong #{kind} index class")
assert_equal( index , slot.index.symbol, "wrong #{kind} index")
assert_equal( Symbol , index.class, "wrong #{kind} index class, at:#{slot_i}")
assert_equal( index , slot.index.symbol, "wrong #{kind} index, at#{slot_i}")
else
assert_equal( index , slot.index, "wrong #{kind} index")
assert_equal( index , slot.index, "wrong #{kind} index, at:#{slot_i}")
end
end
def assert_load(load , clazz = nil , register = nil)
def assert_load(load_i , clazz = nil , register = nil)
assert_equal Integer , load_i.class, "assert_load #{load_i}"
load = risc(load_i)
assert_equal Risc::LoadConstant , load.class
assert_equal( clazz , load.constant.class) if clazz
if register
assert_register(:source , register , load.register)
else
raise "rewrite"
raise "add register at:#{load_i}, as third operand at #{load_i}"
end
end
def assert_transfer( transfer , from , to)
assert_equal Risc::Transfer , transfer.class
assert_register( :source , from , transfer.from )
assert_register( :destination , to , transfer.to )
def assert_transfer( transfer_i , from , to)
assert_equal Integer , transfer_i.class, "assert_transfer #{transfer_i}"
transfer = risc(transfer_i)
assert_equal Risc::Transfer , transfer.class, "Class at #{transfer_i}"
assert_register( :source , from , transfer.from , transfer_i)
assert_register( :destination , to , transfer.to , transfer_i)
end
def assert_label( label , name )
assert_equal Risc::Label , label.class
if(name[-1] == "_")
assert label.name.start_with?(name) , "Label does not start with #{name}:#{label.name}"
def assert_label( label_i , name , at = nil)
if(at)
label = label_i
label_i = at
else
assert_equal name , label.name
assert_equal Integer , label_i.class, "assert_label #{label_i}"
label = risc(label_i)
end
assert_equal Risc::Label , label.class, "Class at:#{label_i}"
if(name[-1] == "_")
assert label.name.start_with?(name) , "Label at:#{label_i} does not start with #{name}:#{label.name}"
else
assert_equal name , label.name , "Label at:#{label_i}"
end
end
def assert_branch( branch , label_name )
assert_equal Risc::Branch , branch.class
assert_label branch.label , label_name
def assert_branch( branch_i , label_name )
assert_equal Integer , branch_i.class, "assert_branch #{branch_i}"
branch = risc(branch_i)
assert_equal Risc::Branch , branch.class , "Class at:#{branch_i}"
assert_label branch.label , label_name , "Label at #{branch_i}"
end
def assert_operator ins , op , left , right
assert_equal Risc::OperatorInstruction , ins.class
def assert_operator ins_i , op , left , right
assert_equal Integer , ins_i.class, "assert_operator #{ins_i}"
ins = risc(ins_i)
assert_equal Risc::OperatorInstruction , ins.class , "Class at:#{ins_i}"
assert_equal op , ins.operator
assert_register :left , left , ins.left
assert_register :right , right , ins.right
assert_register :left , left , ins.left , ins_i
assert_register :right , right , ins.right, ins_i
end
def assert_zero ins , label
assert_equal Risc::IsNotZero , ins.class
assert_label ins.label , label
def assert_zero ins_i , label
assert_equal Integer , ins_i.class, "assert_zero #{ins_i}"
ins = risc(ins_i)
assert_equal Risc::IsNotZero , ins.class , "Class at:#{ins_i}"
assert_label ins.label , label , "Label at:#{ins_i}"
end
def assert_not_zero ins , label
assert_equal Risc::IsZero , ins.class
assert_label ins.label , label
def assert_not_zero ins_i , label
assert_equal Integer , ins_i.class, "assert_not_zero #{ins_i}"
ins = risc(ins_i)
assert_equal Risc::IsZero , ins.class, "Class at:#{ins_i}"
assert_label ins.label , label, "Label at:#{ins_i}"
end
def assert_syscall ins , name
assert_equal Risc::Syscall , ins.class
assert_equal Integer , ins_i.class, "assert_syscall #{ins_i}"
ins = risc(ins_i)
assert_equal Risc::Syscall , ins.class, "Class at:#{ins_i}"
assert_equal ins.name , name
end
def assert_minus ins , label
assert_equal Risc::IsMinus , ins.class
assert_label ins.label , label
def assert_minus ins_i , label
assert_equal Integer , ins_i.class, "assert_minus #{ins_i}"
ins = risc(ins_i)
assert_equal Risc::IsMinus , ins.class, "Class at:#{ins_i}"
assert_label ins.label , label, ins_i
end
def assert_data(ins , data)
assert_equal Risc::LoadData , ins.class
assert_equal data , ins.constant
def assert_data(ins_i , data)
assert_equal Integer , ins_i.class, "assert_data #{ins_i}"
ins = risc(ins_i)
assert_equal Risc::LoadData , ins.class, "Class at:#{ins_i}"
assert_equal data , ins.constant , "Data at:#{ins_i}"
end
end
end