koi-vm-ruby 0.0.4

data/test/setup/test_unit_extensions.rb

@@ -0,0 +1,21 @@
+module Test::Unit
+  # Used to fix a minor minitest/unit incompatibility in flexmock
+  AssertionFailedError = Class.new(StandardError)
+  
+  class TestCase
+   
+    def self.test(name, &block)
+      test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+      defined = instance_method(test_name) rescue false
+      raise "#{test_name} is already defined in #{self}" if defined
+      if block_given?
+        define_method(test_name, &block)
+      else
+        define_method(test_name) do
+          flunk "No implementation provided for #{name}"
+        end
+      end
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+$test = true
+
+require 'rubygems'
+require 'test/unit'
+require 'stringio'
+
+require_files = []
+require_files << File.join(File.dirname(__FILE__), '..', 'lib', 'koi-vm-ruby.rb')
+require_files.concat Dir[File.join(File.dirname(__FILE__), 'setup', '*.rb')]
+
+require_files.each do |file|
+  require File.expand_path(file)
+end

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 KoiVMRuby
+  
+  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 KoiVMRuby
+  
+  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/invert_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper.rb'))
+
+class InvertTest < Test::Unit::TestCase
+
+  include KoiVMRuby
+  
+  test "should invert boolean value true -> false" do
+    vm = VM.new
+    vm.data_stack = [[BOOL_, true]]
+    vm.run [
+      INVERT
+    ]
+    assert_equal [[BOOL_, false]], vm.data_stack
+  end
+  
+  test "should invert boolean value false -> true" do
+    vm = VM.new
+    vm.data_stack = [[BOOL_, false]]
+    vm.run [
+      INVERT
+    ]
+    assert_equal [[BOOL_, true]], vm.data_stack
+  end
+  
+  test "should raise StackError topmost stack value is not a bool" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.data_stack = [[INTEGER_, 1]]
+      vm.run [
+        INVERT
+      ]
+    end
+  end
+  
+  test "should raise StackError if there are no items on the stack" do
+    assert_raises StackError do
+      vm = VM.new
+      vm.run [
+        INVERT
+      ]
+    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 KoiVMRuby
+  
+  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 KoiVMRuby
+  
+  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 KoiVMRuby
+  
+  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 KoiVMRuby
+  
+  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 KoiVMRuby
+  
+  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 KoiVMRuby
+  
+  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