koi-vm 0.0.1

data/test/unit/opcodes/comparative_operations/equal_test.rb

@@ -0,0 +1,116 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class EqualTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (true int)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 2],[INTEGER_, 2]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (false int)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 2],[INTEGER_, 1]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (true nil)" do
+    vm = VM.new
+    vm.data_stack = [[NIL_, nil],[NIL_, nil]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (false nil)" do
+    vm = VM.new
+    vm.data_stack = [[NIL_, 2],[INTEGER_, 1]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (true float)" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 2.0],[FLOAT_, 2.0]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (false float)" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 2.0],[FLOAT_, 1.0]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (true bool)" do
+    vm = VM.new
+    vm.data_stack = [[BOOL_, true],[BOOL_, true]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (false bool)" do
+    vm = VM.new
+    vm.data_stack = [[BOOL_, true],[BOOL_, false]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (true string)" do
+    vm = VM.new
+    vm.data_stack = [[STRING_, "hi"],[STRING_, "hi"]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing equality of topmost 2 stack items (false string)" do
+    vm = VM.new
+    vm.data_stack = [[STRING_, "hi"],[STRING_, ""]]
+    vm.run [
+      EQUAL
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  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 [
+        EQUAL
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        EQUAL
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/comparative_operations/greater_than_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class GreaterThanTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push bool value onto stack representing whether stack[-2] > stack[-1] (2 2)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 2],[INTEGER_, 2]]
+    vm.run [
+      GREATER_THAN
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing whether stack[-2] > stack[-1] (1 2)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 1],[INTEGER_, 2]]
+    vm.run [
+      GREATER_THAN
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing whether stack[-2] > stack[-1] (3 2)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 3],[INTEGER_, 2]]
+    vm.run [
+      GREATER_THAN
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  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 [
+        GREATER_THAN
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        GREATER_THAN
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/comparative_operations/less_than_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class LessThanTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push bool value onto stack representing whether stack[-2] < stack[-1] (2 2)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 2],[INTEGER_, 2]]
+    vm.run [
+      LESS_THAN
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing whether stack[-2] < stack[-1] (1 2)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 1],[INTEGER_, 2]]
+    vm.run [
+      LESS_THAN
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  end
+  
+  test "should push bool value onto stack representing whether stack[-2] < stack[-1] (3 2)" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 3],[INTEGER_, 2]]
+    vm.run [
+      LESS_THAN
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  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 [
+        LESS_THAN
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        LESS_THAN
+      ]
+    end
+  end
+  
+end

data/test/unit/opcodes/control_operations/exit_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class ExitTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should exit" do
+    vm = VM.new
+    vm.run [
+      EXIT,
+      NO_OP,
+      NO_OP,
+      NO_OP
+    ]
+    assert_equal [], vm.data_stack
+    assert_equal 1, vm.instruction_pointer
+  end
+
+  
+end

data/test/unit/opcodes/control_operations/no_op_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class NoOpTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should perform no-op" do
+    vm = VM.new
+    vm.run [
+      NO_OP
+    ]
+    assert_equal [], vm.data_stack
+    assert_equal 1, vm.instruction_pointer
+  end
+
+  
+end

data/test/unit/opcodes/flow_control_operations/jump_if_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class JumpIfTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should set instruction_pointer to 10 when data_stack[0] != (false || nil)" do
+    [[INTEGER_, 0], [STRING_, ""], [BOOL_, true]].each do |x|
+      vm = VM.new
+      vm.data_stack = [x]
+      vm.run [
+        JUMP_IF, 10
+      ]
+      assert_equal 10, vm.instruction_pointer
+    end
+  end
+  
+  test "should not set instruction_pointer to 10 when data_stack[0] == (false || nil)" do
+    [[NIL_, nil], [BOOL_, false]].each do |x|
+      vm = VM.new
+      vm.data_stack = [x]
+      vm.run [
+        JUMP_IF, 10
+      ]
+      assert_equal 2, vm.instruction_pointer
+    end
+  end
+  
+  test "should raise error if there is not at least 1 item on the data stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        JUMP_IF, 20
+      ]
+    end
+  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.data_stack = [[BOOL_, true]]
+        vm.run [
+          JUMP_IF, x
+        ]
+      end
+    end
+  end
+  
+end

data/test/unit/opcodes/flow_control_operations/jump_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class JumpTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should set instruction_pointer to 10" do
+    vm = VM.new
+    vm.run [
+      JUMP, 10
+    ]
+    assert_equal 10, vm.instruction_pointer
+  end
+  
+  test "should set instruction_pointer to 11" do
+    vm = VM.new
+    vm.instruction_pointer = 1
+    vm.run [
+      0,
+      JUMP, 10
+    ]
+    assert_equal 11, 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 [
+          JUMP, x
+        ]
+      end
+    end
+  end
+  
+end

data/test/unit/opcodes/flow_control_operations/jump_unless_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class JumpUnlessTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should not set instruction_pointer to 10 when data_stack[0] != (false || nil)" do
+    [[INTEGER_, 0], [STRING_, ""], [BOOL_, true]].each do |x|
+      vm = VM.new
+      vm.data_stack = [x]
+      vm.run [
+        JUMP_UNLESS, 10
+      ]
+      assert_equal 2, vm.instruction_pointer
+    end
+  end
+  
+  test "should set instruction_pointer to 10 when data_stack[0] == (false || nil)" do
+    [[NIL_, nil], [BOOL_, false]].each do |x|
+      vm = VM.new
+      vm.data_stack = [x]
+      vm.run [
+        JUMP_UNLESS, 10
+      ]
+      assert_equal 10, vm.instruction_pointer
+    end
+  end
+  
+  test "should raise error if there is not at least 1 item on the data stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        JUMP_IF, 20
+      ]
+    end
+  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.data_stack = [[BOOL_, true]]
+        vm.run [
+          JUMP_UNLESS, x
+        ]
+      end
+    end
+  end
+  
+end

data/test/unit/opcodes/function_operations/call_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class CallTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should pass execution to function and push return position on the return stack" do
+    vm = VM.new
+    vm.data_stack = [[FUNCTION_, 101]]
+    vm.run [
+      CALL
+    ]
+    assert_equal [], vm.data_stack
+    assert_equal [1], vm.return_stack
+    assert_equal 101, vm.instruction_pointer
+    assert_equal 1, vm.level
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        CALL
+      ]
+    end
+  end
+  
+  test "should raise StackError if topmost stack item is not a function" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[INTEGER_, 101]]
+      vm.run [
+        CALL
+      ]
+    end
+  end
+
+  
+end

data/test/unit/opcodes/function_operations/push_function_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PushFunctionTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should push function reference onto stack" do
+    vm = VM.new
+    vm.run [
+      PUSH_FUNCTION, 1,
+      NO_OP,
+      NO_OP,
+      END_FUNCTION, 0,
+      END_FUNCTION, 1
+    ]
+    assert_equal [[FUNCTION_, 2]], vm.data_stack
+    assert_equal 8, vm.instruction_pointer
+  end
+
+  
+end

data/test/unit/opcodes/function_operations/return_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class ReturnTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should pass execution to topmost address on return stack and decrement scope" do
+    vm = VM.new
+    vm.return_stack = [101]
+    assert_equal [101], vm.return_stack
+    vm.level = 1
+    vm.run [
+      RETURN
+    ]
+    assert_equal [], vm.data_stack
+    assert_equal [], vm.return_stack
+    assert_equal 101, vm.instruction_pointer
+    assert_equal 0, vm.level
+  end
+  
+  test "should raise ReturnStackError if there are no items on the return stack" do
+    assert_raises ReturnStackError do
+      vm = VM.new
+      vm.run [
+        RETURN
+      ]
+    end
+  end
+
+  
+end

data/test/unit/opcodes/function_operations/tailcall_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class TailcallTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should pass execution to new function without altering return stack, and reload scope" do
+    vm = VM.new
+    vm.data_stack = [[FUNCTION_, 101]]
+    vm.level = 1
+    vm.return_stack = [1]
+    vm.run [
+      TAILCALL
+    ]
+    assert_equal [], vm.data_stack
+    assert_equal [1], vm.return_stack
+    assert_equal 101, vm.instruction_pointer
+    assert_equal 1, vm.level
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        TAILCALL
+      ]
+    end
+  end
+  
+  test "should raise StackError if topmost stack item is not a function" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[INTEGER_, 101]]
+      vm.run [
+        TAILCALL
+      ]
+    end
+  end
+
+  
+end

data/test/unit/opcodes/io_operations/gets_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class GetsTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  require "stringio"
+  
+  test "should get string from stdin and push it onto stack as a string" do
+    input = "Test"
+    old_stdin = $stdin
+    buffer = StringIO.new
+    $stdin = buffer
+    buffer.string = input
+    vm = VM.new
+    vm.run [
+      GETS
+    ]
+    assert_equal [[STRING_, input]], vm.data_stack
+    $stdin = old_stdin
+  end
+  
+  test "should get newline separated strings from stdin and push onto stack as a string" do
+    input = "Test\nstring"
+    old_stdin = $stdin
+    buffer = StringIO.new
+    $stdin = buffer
+    buffer.string = input
+    vm = VM.new
+    vm.run [
+      GETS,
+      GETS
+    ]
+    assert_equal [[STRING_, "Test\n"], [STRING_, "string"]], vm.data_stack
+    $stdin = old_stdin
+  end
+  
+end

data/test/unit/opcodes/io_operations/print_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class PrintTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  require "stringio"
+  
+  test "should print topmost string value from stack" do
+    old_stdout = $stdout
+    buffer = StringIO.new
+    $stdout = buffer
+    vm = VM.new
+    vm.data_stack = [[STRING_, "test"]]
+    vm.run [
+      PRINT
+    ]
+    assert_equal [], vm.data_stack
+    assert_equal "test", buffer.string
+    $stdout = old_stdout
+  end
+  
+  test "should raise StackError if topmost item is not a string" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[INTEGER_, 1]]
+      vm.run [
+        PRINT
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        PRINT
+      ]
+    end
+  end
+  
+end

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

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class AddTest < Test::Unit::TestCase
+
+  include KoiVM
+  
+  test "should add top two integers on stack" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 9], [INTEGER_, 9]]
+    vm.run [
+      ADD
+    ]
+    assert_equal [[INTEGER_, 18]], vm.data_stack
+  end
+  
+  test "should add top two floats on stack" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 9.0], [FLOAT_, 9.0]]
+    vm.run [
+      ADD
+    ]
+    assert_equal [[FLOAT_, 18.0]], vm.data_stack
+  end
+  
+  test "should add top two numbers on stack and implicitly convert them to floats" do
+    vm = VM.new
+    vm.data_stack = [[INTEGER_, 9], [FLOAT_, 9.0]]
+    vm.run [
+      ADD
+    ]
+    assert_equal [[FLOAT_, 18.0]], vm.data_stack
+  end
+  
+  test "should add top two numbers on stack and implicitly convert them to floats if receiver is a float" do
+    vm = VM.new
+    vm.data_stack = [[FLOAT_, 9.0], [INTEGER_, 9]]
+    vm.run [
+      ADD
+    ]
+    assert_equal [[FLOAT_, 18.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 [
+        ADD
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        ADD
+      ]
+    end
+  end
+  
+end