fOOrth 0.5.0

data/tests/core_tests.rb

@@ -0,0 +1,138 @@
+# coding: utf-8
+
+$exclude_fOOrth_library = true
+require_relative '../lib/fOOrth'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the monkey patches applied to the Object class.
+class CoreTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_that_object_handles_no_method_errors
+    #Get an object instance to test with.
+    obj = Object.new
+
+    XfOOrth::SymbolMap.add_entry("a_test_zero", :a_test_zero)
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      obj.a_test_zero
+    end
+
+    assert_raises(NoMethodError) do
+      obj.qwertyuiop
+    end
+  end
+
+  def test_that_shared_methods_can_be_defined
+    #Get an object instance to test with.
+    obj = Object.new
+
+    #Get the virtual machine.
+    vm = Thread.current[:vm]
+
+    XfOOrth::SymbolMap.add_entry("a_test_one", :a_test_one)
+
+    spec = Object.create_shared_method("a_test_one", XfOOrth::TosSpec, []) {|vm| vm.push(9671111) }
+
+    obj.a_test_one(vm)
+
+    assert_equal(9671111, vm.pop)
+    assert_equal(spec, Object.map_foorth_shared(:a_test_one))
+    assert_equal(spec, Class.map_foorth_shared(:a_test_one))
+    assert_equal(spec, Object.foorth_shared[:a_test_one])
+    assert_equal(nil,  Class.foorth_shared[:a_test_one])
+  end
+
+  def test_that_exclusive_methods_can_be_defined
+    #Get an object instance to test with.
+    obj = Object.new
+
+    #Get the virtual machine.
+    vm = XfOOrth::VirtualMachine.vm
+
+    XfOOrth::SymbolMap.add_entry("a_test_two", :a_test_two)
+
+    spec = obj.create_exclusive_method("a_test_two", XfOOrth::TosSpec, []) do |vm|
+      vm.push(9686668)
+    end
+
+    obj.a_test_two(vm)
+
+    assert_equal(9686668, vm.pop)
+    assert_equal(spec, obj.map_foorth_exclusive(:a_test_two))
+    assert_equal(spec, obj.foorth_exclusive[:a_test_two])
+    assert_equal(nil, Object.map_foorth_shared(:a_test_two))
+    assert_equal(nil, Class.map_foorth_shared(:a_test_two))
+  end
+
+  def test_class_naming
+    assert_equal("Object",         Object.foorth_name)
+    assert_equal("Class",          Class.foorth_name)
+    assert_equal("VirtualMachine", XfOOrth::VirtualMachine.foorth_name)
+
+    vm = Thread.current[:vm]
+    assert_equal("VirtualMachine instance <Main>", vm.foorth_name)
+  end
+
+  def test_instance_naming
+    obj = Object.new
+    assert_equal("Object instance", obj.foorth_name)
+
+    vm = Thread.current[:vm]
+    assert_equal("VirtualMachine instance <Main>", vm.foorth_name)
+  end
+
+  def test_that_virtual_machine_rejects_new
+    assert_raises(XfOOrth::XfOOrthError) do
+      XfOOrth::VirtualMachine.new('Fails')
+    end
+  end
+
+  def test_that_the_VM_class_does_not_subclass
+    assert_raises(XfOOrth::XfOOrthError) do
+      XfOOrth::VirtualMachine.create_foorth_subclass("MyClass")
+    end
+  end
+
+  def test_creating_subclasses
+    new_class = Object.create_foorth_subclass('MyClass')
+    symbol = XfOOrth::SymbolMap.map('MyClass')
+
+    assert($FOORTH_GLOBALS[symbol])
+    assert_equal('XfOOrth::ClassSpec instance', new_class.foorth_name)
+    assert_equal(XfOOrth::XfOOrth_MyClass, new_class.new_class)
+    assert_equal(XfOOrth::XfOOrth_MyClass, $FOORTH_GLOBALS[symbol].new_class)
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      no_class = Object.create_foorth_subclass('No Class')
+    end
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      copy_class = Object.create_foorth_subclass('MyClass')
+    end
+  end
+
+  def test_creating_proxies
+    new_proxy = String.create_foorth_proxy
+    symbol = XfOOrth::SymbolMap.map('String')
+
+    assert($FOORTH_GLOBALS[symbol])
+    assert_equal('String', new_proxy.new_class.foorth_name)
+    assert_equal(String, new_proxy.new_class)
+    assert_equal(String, $FOORTH_GLOBALS[symbol].new_class)
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      bad_class = Object.create_foorth_subclass('My Class')
+    end
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      bad_class = Module.create_foorth_proxy('Mod ule')
+    end
+
+  end
+
+end

data/tests/interpreter/data_stack_tests.rb

@@ -0,0 +1,119 @@
+# coding: utf-8
+
+$exclude_fOOrth_library = true
+require_relative '../../lib/fOOrth'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the monkey patches applied to the Object class.
+class DataStackMapTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_data_stack_ops
+    vm = Thread.current[:vm]
+    refute(vm == nil)
+
+    vm.interpreter_reset
+
+    assert_equal(vm.data_stack, [])
+    vm.push(4)
+    assert_equal(vm.data_stack, [4])
+    vm.push(8)
+    assert_equal(vm.data_stack, [4, 8])
+    assert_equal(vm.peek, 8)
+    assert_equal(vm.peek(1), 8)
+    assert_equal(vm.peek(2), 4)
+    assert_equal(vm.pop, 8)
+    assert_equal(vm.data_stack, [4])
+    assert_equal(vm.pop, 4)
+    assert_equal(vm.data_stack, [])
+
+    vm.push(8)
+    assert_equal(vm.data_stack, [8])
+    vm.pushm([1,2,3])
+    assert_equal(vm.data_stack, [8, 1, 2, 3])
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      vm.peek(-1)
+    end
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      vm.peek(0)
+    end
+  end
+
+  def test_boolean_stack_data
+    vm = Thread.current[:vm]
+    refute(vm == nil)
+
+    vm.interpreter_reset
+
+    vm.push(16)
+    assert(vm.pop?)
+
+    vm.push(true)
+    assert(vm.pop?)
+
+    vm.push('test')
+    assert(vm.pop?)
+
+    vm.push(0)
+    assert(vm.pop?)
+
+    vm.push(false)
+    refute(vm.pop?)
+
+    vm.push('')
+    assert(vm.pop?)
+
+    vm.push(nil)
+    refute(vm.pop?)
+  end
+
+  def test_pop_multiple
+    vm = Thread.current[:vm]
+    refute(vm == nil)
+
+    vm.interpreter_reset
+
+    vm.push(16)
+    vm.push(true)
+    vm.push('test')
+    vm.push(0)
+    vm.push('')
+    vm.push(nil)
+
+    assert_equal(vm.data_stack, [16, true, 'test', 0, '', nil])
+    assert_equal(vm.popm(3), [0, '', nil])
+    assert_equal(vm.popm(3), [16, true, 'test'])
+    assert_equal(vm.data_stack, [])
+  end
+
+  def test_poke
+    vm = Thread.current[:vm]
+    refute(vm == nil)
+
+    vm.interpreter_reset
+
+    vm.push(42)
+    vm.poke("hello")
+    assert_equal(vm.data_stack, ["hello"])
+  end
+
+  def test_swap_pop
+    vm = Thread.current[:vm]
+    refute(vm == nil)
+
+    vm.interpreter_reset
+
+    vm.push(16)
+    vm.push(99)
+    assert_equal(vm.swap_pop, 16)
+    assert_equal(vm.pop, 99)
+    assert_equal(vm.data_stack, [])
+  end
+
+end

data/tests/monkey_patch/coerce_test.rb

@@ -0,0 +1,131 @@
+# coding: utf-8
+
+require_relative '../../lib/fOOrth/monkey_patch'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the monkey patches applied to the coerce protocol.
+class CoerceProtocolTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  #Test the default stubs.
+  def test_object_stubs
+    obj = Object.new
+
+    assert_raises(XfOOrth::XfOOrthError) { obj.foorth_coerce(42) }
+  end
+
+  def test_coerce_for_integers
+    obj = Object.new
+
+    assert_equal(42, (3).foorth_coerce(42))
+    assert_equal(Fixnum, (3).foorth_coerce(42).class)
+
+    assert_equal(42, (3).foorth_coerce('42'))
+    assert_equal(Fixnum, (3).foorth_coerce('42').class)
+
+    assert_raises(XfOOrth::XfOOrthError) { (3).foorth_coerce('turnip') }
+    assert_raises(XfOOrth::XfOOrthError) { (3).foorth_coerce(obj) }
+    assert_raises(XfOOrth::XfOOrthError) { (3).foorth_coerce(nil) }
+
+    assert_equal(42, Integer.foorth_coerce(42))
+    assert_equal(Fixnum, Integer.foorth_coerce(42).class)
+
+    assert_equal(42, Integer.foorth_coerce('42'))
+    assert_equal(Fixnum, Integer.foorth_coerce('42').class)
+
+    assert_raises(XfOOrth::XfOOrthError) { Integer.foorth_coerce('turnip') }
+    assert_raises(XfOOrth::XfOOrthError) { Integer.foorth_coerce(obj) }
+    assert_raises(XfOOrth::XfOOrthError) { Integer.foorth_coerce(nil) }
+
+  end
+
+  def test_coerce_for_floats
+    obj = Object.new
+
+    assert_equal(42.0, (3.0).foorth_coerce(42))
+    assert_equal(Float, (3.0).foorth_coerce(42).class)
+
+    assert_equal(42.0, (3.0).foorth_coerce(42.0))
+    assert_equal(Float, (3.0).foorth_coerce(42.0).class)
+
+    assert_equal(42.0, (3.0).foorth_coerce('42'))
+    assert_equal(Float, (3.0).foorth_coerce('42').class)
+
+    assert_equal(42.0, (3.0).foorth_coerce('42.0'))
+    assert_equal(Float, (3.0).foorth_coerce('42.0').class)
+
+    assert_raises(XfOOrth::XfOOrthError) { (3.0).foorth_coerce('turnip') }
+    assert_raises(XfOOrth::XfOOrthError) { (3.0).foorth_coerce(obj) }
+    assert_raises(XfOOrth::XfOOrthError) { (3.0).foorth_coerce(nil) }
+
+    assert_equal(42.0, Float.foorth_coerce(42))
+    assert_equal(Float, Float.foorth_coerce(42).class)
+
+    assert_equal(42.0, Float.foorth_coerce(42.0))
+    assert_equal(Float, Float.foorth_coerce(42.0).class)
+
+    assert_equal(42.0, Float.foorth_coerce('42'))
+    assert_equal(Float, Float.foorth_coerce('42').class)
+
+    assert_equal(42.0, Float.foorth_coerce('42.0'))
+    assert_equal(Float, Float.foorth_coerce('42.0').class)
+
+    assert_raises(XfOOrth::XfOOrthError) { Float.foorth_coerce('turnip') }
+    assert_raises(XfOOrth::XfOOrthError) { Float.foorth_coerce(obj) }
+    assert_raises(XfOOrth::XfOOrthError) { Float.foorth_coerce(nil) }
+  end
+
+  def test_coerce_for_rationals
+    obj = Object.new
+
+    assert_equal('42/1'.to_r, ('3/1'.to_r).foorth_coerce(42))
+    assert_equal(Rational, ('3/1'.to_r).foorth_coerce(42).class)
+
+    assert_equal('42/1'.to_r, ('3/1'.to_r).foorth_coerce(42.0))
+    assert_equal(Rational, ('3/1'.to_r).foorth_coerce(42.0).class)
+
+    assert_equal('42/1'.to_r, ('3/1'.to_r).foorth_coerce('42'))
+    assert_equal(Rational, ('3/1'.to_r).foorth_coerce('42').class)
+
+    assert_equal('42/1'.to_r, ('3/1'.to_r).foorth_coerce('42.0'))
+    assert_equal(Rational, ('3/1'.to_r).foorth_coerce('42.0').class)
+
+    assert_equal('42/1'.to_r, ('3/1'.to_r).foorth_coerce('42/1'))
+    assert_equal(Rational, ('3/1'.to_r).foorth_coerce('42/1').class)
+
+    assert_raises(XfOOrth::XfOOrthError) { ('3/1'.to_r).foorth_coerce('turnip') }
+    assert_raises(XfOOrth::XfOOrthError) { ('3/1'.to_r).foorth_coerce(obj) }
+    assert_raises(XfOOrth::XfOOrthError) { ('3/1'.to_r).foorth_coerce(nil) }
+  end
+
+  def test_coerce_for_complex
+    obj = Object.new
+
+    assert_equal('42+0i'.to_c, ('1+1i'.to_c).foorth_coerce(42))
+    assert_equal(Complex, ('1+1i'.to_c).foorth_coerce(42).class)
+
+    assert_equal('42+0i'.to_c, ('1+1i'.to_c).foorth_coerce(42.0))
+    assert_equal(Complex, ('1+1i'.to_c).foorth_coerce(42.0).class)
+
+    assert_equal('42+0i'.to_c, ('1+1i'.to_c).foorth_coerce('42/1'.to_r))
+    assert_equal(Complex, ('1+1i'.to_c).foorth_coerce('42/1'.to_r).class)
+
+    assert_equal('42+0i'.to_c, ('1+1i'.to_c).foorth_coerce('42'))
+    assert_equal(Complex, ('1+1i'.to_c).foorth_coerce('42').class)
+
+    assert_equal('42+0i'.to_c, ('1+1i'.to_c).foorth_coerce('42.0'))
+    assert_equal(Complex, ('1+1i'.to_c).foorth_coerce('42.0').class)
+
+    assert_equal('42+0i'.to_c, ('1+1i'.to_c).foorth_coerce('42/1'))
+    assert_equal(Complex, ('1+1i'.to_c).foorth_coerce('42/1').class)
+
+    assert_raises(XfOOrth::XfOOrthError) { ('1+1i'.to_c).foorth_coerce('turnip') }
+    assert_raises(XfOOrth::XfOOrthError) { ('1+1i'.to_c).foorth_coerce(obj) }
+    assert_raises(XfOOrth::XfOOrthError) { ('1+1i'.to_c).foorth_coerce(nil) }
+  end
+
+end

data/tests/monkey_patch/complex_test.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require_relative '../../lib/fOOrth/monkey_patch/numeric'
+require_relative '../../lib/fOOrth/monkey_patch/complex'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the monkey patches applied to the Object class.
+class ComplexMonkeyPatchTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  #Test that it embeds
+  def test_foorth_embed
+    comp = Complex(1,2)
+    assert_equal(comp.foorth_embed, 'Complex(1,2)')
+  end
+
+  def test_that_it_is_not_rationalizable
+    comp = Complex(1,2)
+    assert_equal(nil, comp.to_foorth_r)
+  end
+end

data/tests/monkey_patch/numeric_test.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+
+require_relative '../../lib/fOOrth/monkey_patch/numeric'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the monkey patches applied to the Object class.
+class NumericMonkeyPatchTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  #Test that it embeds
+  def test_foorth_embed
+    assert_equal(5.foorth_embed, '5')
+    assert_equal((5.1).foorth_embed, '5.1')
+  end
+
+  #Test for conversion to a character.
+  def test_to_character
+    assert_equal(65.to_foorth_c, 'A')
+    assert_equal((65.0).to_foorth_c, 'A')
+    assert_equal(Rational(65,1).to_foorth_c, 'A')
+
+    assert_equal(127.to_foorth_c, "\u007F")
+    assert_equal(128.to_foorth_c, "\u0080")
+
+    assert_equal(255.to_foorth_c, "\u00FF")
+    assert_equal(256.to_foorth_c, "\u0100")
+
+    assert_equal(169.to_foorth_c, "\u00A9")
+    assert_equal(1120.to_foorth_c, "\u0460")
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      Complex(65,0).to_foorth_c
+    end
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      1114112.to_foorth_c
+    end
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      (-2).to_foorth_c
+    end
+  end
+
+  #Test for conversion to a numeric.
+  def test_to_number
+    assert_equal(65.to_foorth_n, 65)
+    assert_equal((65.1).to_foorth_n, 65.1)
+    assert_equal(Complex(65,0).to_foorth_n, Complex(65,0))
+    assert_equal(Rational(65,1).to_foorth_n, Rational(65,1))
+  end
+
+  #Test for conversion to a rational.
+  def test_to_rational
+    assert_equal(Rational(13,10), (1.3).to_foorth_r)
+  end
+
+end
+