koi-vm 0.0.1

data/test/unit/opcodes/math_operations/divide_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class DivideTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should divide top two integers on stack" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 10], [INTEGER_, 3]]
+    vm.run [
+      DIVIDE
+    ]
+    assert_equal [[INTEGER_, 3]], vm.data_stack
+  end
+  
+  test "should divide top two floats on stack" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 10.0], [FLOAT_, 3.0]]
+    vm.run [
+      DIVIDE
+    ]
+    assert_equal [[FLOAT_, 10.0 / 3.0]], vm.data_stack
+  end
+  
+  test "should divide top two numbers on stack and implicitly convert them to floats" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 10], [FLOAT_, 3.0]]
+    vm.run [
+      DIVIDE
+    ]
+    assert_equal [[FLOAT_, 10.0 / 3.0]], vm.data_stack
+  end
+  
+  test "should divide top two numbers on stack and implicitly convert them to floats if receiver is a float" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 10.0], [INTEGER_, 3]]
+    vm.run [
+      DIVIDE
+    ]
+    assert_equal [[FLOAT_, 10.0 / 3.0]], vm.data_stack
+  end
+  
+  test "should raise StackError if there is only one item on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [1]
+      vm.run [
+        DIVIDE
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        DIVIDE
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/math_operations/multiply_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class MultiplyTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should multiply top two integers on stack" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 5], [INTEGER_, 2]]
+    vm.run [
+      MULTIPLY
+    ]
+    assert_equal [[INTEGER_, 10]], vm.data_stack
+  end
+  
+  test "should multiply top two floats on stack" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 5.0], [FLOAT_, 2.0]]
+    vm.run [
+      MULTIPLY
+    ]
+    assert_equal [[FLOAT_, 10.0]], vm.data_stack
+  end
+  
+  test "should multiply top two numbers on stack and implicitly convert them to floats" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 5], [FLOAT_, 2.0]]
+    vm.run [
+      MULTIPLY
+    ]
+    assert_equal [[FLOAT_, 10.0]], vm.data_stack
+  end
+  
+  test "should multiply top two numbers on stack and implicitly convert them to floats if receiver is a float" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 5.0], [INTEGER_, 2]]
+    vm.run [
+      MULTIPLY
+    ]
+    assert_equal [[FLOAT_, 10.0]], vm.data_stack
+  end
+  
+  test "should raise StackError if there is only one item on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [1]
+      vm.run [
+        MULTIPLY
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        MULTIPLY
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/math_operations/subtract_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class SubtractTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should subtract top two integers on stack" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 5], [INTEGER_, 2]]
+    vm.run [
+      SUBTRACT
+    ]
+    assert_equal [[INTEGER_, 3]], vm.data_stack
+  end
+  
+  test "should subtract top two floats on stack" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 5.0], [FLOAT_, 2.0]]
+    vm.run [
+      SUBTRACT
+    ]
+    assert_equal [[FLOAT_, 3.0]], vm.data_stack
+  end
+  
+  test "should subtract top two numbers on stack and implicitly convert them to floats" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 5], [FLOAT_, 2.0]]
+    vm.run [
+      SUBTRACT
+    ]
+    assert_equal [[FLOAT_, 3.0]], vm.data_stack
+  end
+  
+  test "should subtract top two numbers on stack and implicitly convert them to floats if receiver is a float" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 5.0], [INTEGER_, 2]]
+    vm.run [
+      SUBTRACT
+    ]
+    assert_equal [[FLOAT_, 3.0]], vm.data_stack
+  end
+  
+  test "should raise StackError if there is only one item on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [1]
+      vm.run [
+        SUBTRACT
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        SUBTRACT
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/push_operations/push_bool_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PushBoolTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should put true onto stack" do
+    vm = VM.new
+    vm.run [
+      PUSH_BOOL, true
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+    assert_equal 2, vm.instruction_pointer
+  end
+  
+  test "should put false onto stack" do
+    vm = VM.new
+    vm.run [
+      PUSH_BOOL, false
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+    assert_equal 2, vm.instruction_pointer
+  end
+  
+  test "should raise error if operand is not a boolean value" do
+    [1,2.0,"string", [1], {:t=>1}].each do |x|
+      assert_raises OperandError do
+        vm = VM.new
+        vm.run [
+          PUSH_BOOL, x
+        ]
+      end
+    end
+  end
+  
+end

data/test/unit/opcodes/push_operations/push_float_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PushFloatTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push float onto stack" do
+    vm = VM.new
+    vm.run [
+      PUSH_FLOAT, 99.9
+    ]
+    assert_equal [[FLOAT_, 99.9]], vm.data_stack
+    assert_equal 2, vm.instruction_pointer
+  end
+  
+  test "should raise error if operand is not a float" do
+    [false, 2, "string", [1], {:t=>1}].each do |x|
+      assert_raises OperandError do
+        vm = VM.new
+        vm.run [
+          PUSH_FLOAT, x
+        ]
+      end
+    end
+  end
+  
+end

data/test/unit/opcodes/push_operations/push_int_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PushIntTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should put integer onto stack" do
+    vm = VM.new
+    vm.run [
+      PUSH_INT, 99
+    ]
+    assert_equal [[INTEGER_, 99]], vm.data_stack
+    assert_equal 2, vm.instruction_pointer
+  end
+  
+  test "should raise error if operand is not an integer" do
+    [false, 2.0, "string", [1], {:t=>1}].each do |x|
+      assert_raises OperandError do
+        vm = VM.new
+        vm.run [
+          PUSH_INT, x
+        ]
+      end
+    end
+  end
+  
+end

data/test/unit/opcodes/push_operations/push_nil_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PushNilTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should put nil onto stack" do
+    vm = VM.new
+    vm.run [
+      PUSH_NIL
+    ]
+    assert_equal [[NIL_, nil]], vm.data_stack
+    assert_equal 1, vm.instruction_pointer
+  end
+  
+end

data/test/unit/opcodes/push_operations/push_string_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PushStringTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push string onto stack" do
+    vm = VM.new
+    vm.run [
+      PUSH_STRING, "test"
+    ]
+    assert_equal [[STRING_, "test"]], vm.data_stack
+    assert_equal 2, vm.instruction_pointer
+  end
+  
+  test "should raise error if operand is not a string" do
+    [false, 2, 2.0, [1], {:t=>1}].each do |x|
+      assert_raises OperandError do
+        vm = VM.new
+        vm.run [
+          PUSH_STRING, x
+        ]
+      end
+    end
+  end
+  
+end

data/test/unit/opcodes/stack_operations/dup_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class DupTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should duplicate the topmost item on the data stack" do
+    vm = VM.new
+    vm.data_stack = [2]
+    vm.run [
+      DUP
+    ]
+    assert_equal [2,2], vm.data_stack
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        DUP
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/stack_operations/pop_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PopTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should pop a single item off the data stack" do
+    (1..10).each do |x|
+      vm = VM.new
+      vm.data_stack.fill("x", 0..(x - 1))
+      assert_equal x, vm.data_stack.length
+      vm.run [
+        POP
+      ]
+      assert_equal x - 1, vm.data_stack.length
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        POP
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/stack_operations/stksize_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class StksizeTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push an integer onto the stack representing the number of entries on the stack before the call" do
+    (1..10).each do |x|
+      vm = VM.new
+      vm.data_stack.fill("x", 0..(x - 1))
+      assert_equal x, vm.data_stack.length
+      vm.data_stack.length
+      vm.run [
+        STKSIZE
+      ]
+      assert_equal [INTEGER_, vm.data_stack.length - 1], vm.data_stack.last
+    end
+  end
+  
+end

data/test/unit/opcodes/stack_operations/swap_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class SwapTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should swap the two topmost items on the data stack" do
+    vm = VM.new
+    vm.data_stack = [1,2]
+    vm.run [
+      SWAP
+    ]
+    assert_equal [2,1], vm.data_stack
+    assert_equal 1, vm.instruction_pointer
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        SWAP
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are less than 2 items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [1]
+      vm.run [
+        SWAP
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/stack_operations/top_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class TopTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should duplicate the topmost n items on the data stack" do
+    vm = VM.new
+    vm.data_stack = [1,2,2]
+    vm.run [
+      TOP, 2
+    ]
+    assert_equal [1,2,2,2,2], vm.data_stack
+  end
+  
+  test "should raise OperandError if operand is not an integer" do
+    assert_raises OperandError do
+      vm = VM.new
+      vm.data_stack = [1,2]
+      vm.run [
+        TOP, "a"
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are not enough items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [1]
+      vm.run [
+        TOP, 2
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        TOP, 2
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/stack_operations/typeof_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class TypeofTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push string representing type of topmost stack item onto the stack (nil)" do
+    vm = VM.new
+    vm.data_stack = [[NIL_, nil]]
+    vm.run [
+      TYPEOF
+    ]
+    assert_equal [[STRING_, "nil"]], vm.data_stack
+  end
+  
+  test "should push string representing type of topmost stack item onto the stack (bool)" do
+    vm = VM.new
+    vm.data_stack = [[BOOL_, true]]
+    vm.run [
+      TYPEOF
+    ]
+    assert_equal [[STRING_, "bool"]], vm.data_stack
+  end
+  
+  test "should push string representing type of topmost stack item onto the stack (integer)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 1]]
+    vm.run [
+      TYPEOF
+    ]
+    assert_equal [[STRING_, "integer"]], vm.data_stack
+  end
+  
+  test "should push string representing type of topmost stack item onto the stack (float)" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 1.0]]
+    vm.run [
+      TYPEOF
+    ]
+    assert_equal [[STRING_, "float"]], vm.data_stack
+  end
+  
+  test "should push string representing type of topmost stack item onto the stack (string)" do
+    vm = VM.new
+    vm.data_stack = [[STRING_, true]]
+    vm.run [
+      TYPEOF
+    ]
+    assert_equal [[STRING_, "string"]], vm.data_stack
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        TYPEOF
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/string_operations/concat_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class ConcatTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should add top two strings on stack" do
+    vm = VM.new
+    vm.data_stack = [[STRING_, "hi"], [STRING_, "hi"]]
+    vm.run [
+      CONCAT
+    ]
+    assert_equal [[STRING_, "hihi"]], vm.data_stack
+  end
+  
+  test "should raise StackError if either of the top two stack items are not strings 1" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[STRING_, "hi"], [INTEGER_, 1]]
+      vm.run [
+        CONCAT
+      ]
+    end
+  end
+  
+  test "should raise StackError if either of the top two stack items are not strings 2" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[INTEGER_, 1], [STRING_, "hi"]]
+      vm.run [
+        CONCAT
+      ]
+    end
+  end
+  
+  test "should raise StackError if either of the top two stack items are not strings 3" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[INTEGER_, 1], [INTEGER_, 1]]
+      vm.run [
+        CONCAT
+      ]
+    end
+  end
+  
+  test "should raise StackError if there is only one item on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [1]
+      vm.run [
+        CONCAT
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        CONCAT
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/string_operations/strlen_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class StrlenTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push length of topmost string onto stack 1" do
+    vm = VM.new
+    vm.data_stack = [[STRING_, "hi"]]
+    vm.run [
+      STRLEN
+    ]
+    assert_equal [[INTEGER_, 2]], vm.data_stack
+  end
+  
+  test "should push length of topmost string onto stack 2" do
+    vm = VM.new
+    vm.data_stack = [[STRING_, "hihi"]]
+    vm.run [
+      STRLEN
+    ]
+    assert_equal [[INTEGER_, 4]], vm.data_stack
+  end
+  
+  test "should raise StackError if topmost item is not a string" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[STRING_, "hi"], [INTEGER_, 1]]
+      vm.run [
+        STRLEN
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        STRLEN
+      ]
+    end
+  end
+  
+end