fix comparison test and helpers
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:
@ -19,42 +19,41 @@ module SlotMachine
|
||||
end
|
||||
|
||||
def assert_return(at)
|
||||
assert_label risc(at) , "return_label"
|
||||
assert_slot_to_reg risc(at + 1) , :r0 , 5 , :r1
|
||||
assert_slot_to_reg risc(at + 2) , :r0 , 6 , :r2
|
||||
assert_reg_to_slot risc(at + 3) ,:r1 , :r2 , 5
|
||||
assert_slot_to_reg risc(at + 4) , :r0 , 4 , :r3
|
||||
assert_slot_to_reg risc(at + 5) , :r3 , 2 , :r3
|
||||
assert_slot_to_reg risc(at + 6) , :r0 , 6 , :r0
|
||||
assert_equal Risc::FunctionReturn , risc(at + 7).class
|
||||
assert_label risc(at + 8) , "unreachable"
|
||||
assert_label at , "return_label"
|
||||
assert_slot_to_reg at + 1 , :message , 6 , "message.caller"
|
||||
assert_slot_to_reg at + 2 , "message.caller" , 5 , "message.caller.return_value"
|
||||
assert_reg_to_slot at + 3 ,"message.caller.return_value" , "message.caller" , 5
|
||||
assert_slot_to_reg at + 4 , :message , 4 , "message.return_address"
|
||||
assert_slot_to_reg at + 5 , :message , 6 , :message
|
||||
assert_equal Risc::FunctionReturn , risc(at + 6).class
|
||||
assert_label at + 7 , "unreachable"
|
||||
end
|
||||
def assert_allocate
|
||||
assert_load risc(1) , Parfait::Factory
|
||||
assert_slot_to_reg risc(2) , :r2 , 2 , :r1
|
||||
assert_load risc(3) , Parfait::NilClass
|
||||
assert_operator risc(4) , :- , :r3 , :r1
|
||||
assert_equal Risc::IsNotZero , risc(5).class
|
||||
assert_load 1 , Parfait::Factory
|
||||
assert_slot_to_reg 2 , :r2 , 2 , :r1
|
||||
assert_load 3 , Parfait::NilClass
|
||||
assert_operator 4 , :- , :r3 , :r1
|
||||
assert_not_zero 5 , :label
|
||||
assert risc(5).label.name.to_s.start_with?("cont_label")
|
||||
assert_slot_to_reg risc(6) , :r2 , 3 , :r4
|
||||
assert_reg_to_slot risc(7) ,:r4 , :r2 , 2
|
||||
assert_load risc(8) , Parfait::CallableMethod
|
||||
assert_slot_to_reg risc(9) , :r0 , 1 , :r6
|
||||
assert_reg_to_slot risc(10) , :r5 , :r6 , 7
|
||||
assert_load risc(11) , Parfait::Factory
|
||||
assert_reg_to_slot risc(12) , :r7 , :r0 , 2
|
||||
assert_load risc(13) , Risc::Label
|
||||
assert_slot_to_reg risc(14) , :r0 , 1 , :r9
|
||||
assert_slot_to_reg risc(14),:r0,1,:r9
|
||||
assert_reg_to_slot risc(15),:r8,:r9,4
|
||||
assert_slot_to_reg risc(16),:r0 , 1 , :r0
|
||||
assert_slot_to_reg 6 , :r2 , 3 , :r4
|
||||
assert_reg_to_slot 7 ,:r4 , :r2 , 2
|
||||
assert_load 8 , Parfait::CallableMethod
|
||||
assert_slot_to_reg 9 , :r0 , 1 , :r6
|
||||
assert_reg_to_slot 10 , :r5 , :r6 , 7
|
||||
assert_load 11 , Parfait::Factory
|
||||
assert_reg_to_slot 12 , :r7 , :r0 , 2
|
||||
assert_load 13 , Risc::Label
|
||||
assert_slot_to_reg 14 , :r0 , 1 , :r9
|
||||
assert_slot_to_reg 14 ,:r0,1,:r9
|
||||
assert_reg_to_slot 15 ,:r8,:r9,4
|
||||
assert_slot_to_reg 16 ,:r0 , 1 , :r0
|
||||
assert_equal Risc::FunctionCall, risc(17).class
|
||||
assert_equal :main, risc(17).method.name
|
||||
assert_label risc(18) , "continue_"
|
||||
assert_slot_to_reg risc(19) , :r2 , 2 , :r1
|
||||
assert_label risc(20) ,"cont_label_"
|
||||
assert_slot_to_reg risc(21) , :r1 , 1 , :r4
|
||||
assert_reg_to_slot risc(22) , :r4 , :r2 , 2
|
||||
assert_label 18 , "continue_"
|
||||
assert_slot_to_reg 19 , :r2 , 2 , :r1
|
||||
assert_label 20 ,"cont_label_"
|
||||
assert_slot_to_reg 21 , :r1 , 1 , :r4
|
||||
assert_reg_to_slot 22 , :r4 , :r2 , 2
|
||||
end
|
||||
end
|
||||
end
|
||||
|
@ -20,35 +20,35 @@ module SlotMachine
|
||||
end
|
||||
class TestIntComp2Risc < BootTest
|
||||
def setup
|
||||
@method = get_compiler("Integer",:ge)
|
||||
@method = get_compiler("Integer",:gt)
|
||||
end
|
||||
def test_slot_length
|
||||
assert_equal :>= , @method.callable.name
|
||||
assert_equal :> , @method.callable.name
|
||||
assert_equal 7 , @method.slot_instructions.length
|
||||
end
|
||||
def test_compile
|
||||
assert_equal Risc::MethodCompiler , @method.to_risc.class
|
||||
end
|
||||
def test_risc_length
|
||||
assert_equal 24 , @method.to_risc.risc_instructions.length
|
||||
assert_equal 25 , @method.to_risc.risc_instructions.length
|
||||
end
|
||||
def test_all
|
||||
assert_slot_to_reg risc(1),:r0 , 2 , :r1
|
||||
assert_slot_to_reg risc(2),:r1 , 2 , :r1
|
||||
assert_slot_to_reg risc(3),:r0 , 9 , :r2
|
||||
assert_slot_to_reg risc(4),:r2 , 2 , :r2
|
||||
assert_operator risc(5) , :- , :r1 , :r2
|
||||
assert_minus risc(6) , "false_label_"
|
||||
assert_zero risc(7) , "false_label_"
|
||||
assert_load risc(8) , Parfait::TrueClass
|
||||
assert_branch risc(9) , "merge_label_"
|
||||
assert_label risc(10) , "false_label_"
|
||||
assert_load risc(11) , Parfait::FalseClass
|
||||
assert_label risc(12) , "merge_label_"
|
||||
assert_reg_to_slot risc(13) , :r3 , :r0 , 5
|
||||
assert_slot_to_reg risc(14),:r0 , 5 , :r2
|
||||
assert_reg_to_slot risc(15) , :r2 , :r0 , 5
|
||||
assert_branch risc(16) , "return_label"
|
||||
assert_slot_to_reg 1 , :message , 2 , "message.receiver"
|
||||
assert_slot_to_reg 2 , "message.receiver" , 2 , "message.receiver"
|
||||
assert_slot_to_reg 3 ,:message , 9 , "message.arg1"
|
||||
assert_slot_to_reg 4 , "message.arg1" , 2 , "message.arg1"
|
||||
assert_operator 5 , :- , "message.receiver" , "message.arg1"
|
||||
assert_minus 6 , "false_label_"
|
||||
assert_zero 7 , "false_label_"
|
||||
assert_load 8 , Parfait::TrueClass , :result
|
||||
assert_branch 9 , "merge_label_"
|
||||
assert_label 10 , "false_label_"
|
||||
assert_load 11 , Parfait::FalseClass , :result
|
||||
assert_label 12 , "merge_label_"
|
||||
assert_reg_to_slot 13 , :result , :message , 5
|
||||
assert_slot_to_reg 14 ,:message , 5 , "message.return_value"
|
||||
assert_reg_to_slot 15 , "message.return_value" , :message , 5
|
||||
assert_branch 16 , "return_label"
|
||||
end
|
||||
def test_return
|
||||
assert_return(17)
|
||||
|
Reference in New Issue
Block a user