fOOrth 0.6.10 → 0.6.11

data/lib/fOOrth/library/procedure_library.rb

@@ -1,65 +1,69 @@
-# coding: utf-8
-
-#* library/procedure_library.rb - Proc support for the fOOrth library.
-module XfOOrth
-
-  #Connect the Proc class to the fOOrth class system.
-  Proc.create_foorth_proxy('Procedure')
-
-  # A no operation place holder for procedure literals
-  VirtualMachine.create_shared_method('{{', MacroSpec, [:macro, " "])
-
-  # [procedure] .call [unspecified]
-  Proc.create_shared_method('.call', TosSpec, [],
-    &lambda {|vm| self.call(vm); })
-
-  # [owner procedure] .call_with [unspecified]
-  Proc.create_shared_method('.call_with', TosSpec, [],
-    &lambda {|vm| vm.pop.instance_exec(vm, &self); })
-
-  # [v procedure] .call_v [unspecified]
-  Proc.create_shared_method('.call_v', TosSpec, [],
-    &lambda {|vm| value = vm.pop; self.call(vm, value); })
-
-  # [x procedure] .call_x [unspecified]
-  Proc.create_shared_method('.call_x', TosSpec, [],
-    &lambda {|vm| index = vm.pop; self.call(vm, nil, index); })
-
-  # [v x procedure] .call_vx [unspecified]
-  Proc.create_shared_method('.call_vx', TosSpec, [],
-    &lambda {|vm| value, index = vm.popm(2); self.call(vm, value, index); })
-
-  # [procedure] .start [a_thread]
-  Proc.create_shared_method('.start', TosSpec, [], &lambda {|vm|
-    vm.push(self.do_thread_start(vm, '-'))
-  })
-
-  # [name procedure] .start_named [a_thread]
-  Proc.create_shared_method('.start_named', TosSpec, [], &lambda {|vm|
-    vm.push(self.do_thread_start(vm, vm.pop.to_s.freeze))
-  })
-
-end
-
-#A helper method in the Proc class for fOOrth threads.
-class Proc
-  #Do the mechanics of starting a thread.
-  def do_thread_start(vm, vm_name)
-    block, interlock = self, Queue.new
-
-    result = Thread.new(vm.foorth_copy(vm_name)) do |vm_copy|
-
-      begin
-        self.foorth_init(vm_copy.compiler_reset.connect_vm_to_thread)
-      ensure
-        interlock.push(:ready)
-      end
-
-      vm_copy.instance_exec(vm_copy, &block)
-    end
-
-    interlock.pop
-    result
-  end
-end
-
+# coding: utf-8
+
+#* library/procedure_library.rb - Proc support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Proc class to the fOOrth class system.
+  Proc.create_foorth_proxy('Procedure')
+
+  # A no operation place holder for procedure literals. This may seem odd but
+  # works because any word ending in '{{' is assumed to have a procedure literal
+  # attached to it. This is handled in compiler/process/procedure.rb. This code
+  # handles compiling the procedure and pushing a reference to it on the stack.
+  # Once this is done, this word need do nothing further so is a no-op.
+  VirtualMachine.create_shared_method('{{', MacroSpec, [:macro, " "])
+
+  # [procedure] .call [unspecified]
+  Proc.create_shared_method('.call', TosSpec, [],
+    &lambda {|vm| self.call(vm); })
+
+  # [owner procedure] .call_with [unspecified]
+  Proc.create_shared_method('.call_with', TosSpec, [],
+    &lambda {|vm| vm.pop.instance_exec(vm, &self); })
+
+  # [v procedure] .call_v [unspecified]
+  Proc.create_shared_method('.call_v', TosSpec, [],
+    &lambda {|vm| value = vm.pop; self.call(vm, value); })
+
+  # [x procedure] .call_x [unspecified]
+  Proc.create_shared_method('.call_x', TosSpec, [],
+    &lambda {|vm| index = vm.pop; self.call(vm, nil, index); })
+
+  # [v x procedure] .call_vx [unspecified]
+  Proc.create_shared_method('.call_vx', TosSpec, [],
+    &lambda {|vm| value, index = vm.popm(2); self.call(vm, value, index); })
+
+  # [procedure] .start [a_thread]
+  Proc.create_shared_method('.start', TosSpec, [], &lambda {|vm|
+    vm.push(self.do_thread_start(vm, '-'))
+  })
+
+  # [name procedure] .start_named [a_thread]
+  Proc.create_shared_method('.start_named', TosSpec, [], &lambda {|vm|
+    vm.push(self.do_thread_start(vm, vm.pop.to_s.freeze))
+  })
+
+end
+
+#A helper method in the Proc class for fOOrth threads.
+class Proc
+  #Do the mechanics of starting a thread.
+  def do_thread_start(vm, vm_name)
+    block, interlock = self, Queue.new
+
+    result = Thread.new(vm.foorth_copy(vm_name)) do |vm_copy|
+
+      begin
+        self.foorth_init(vm_copy.compiler_reset.connect_vm_to_thread)
+      ensure
+        interlock.push(:ready)
+      end
+
+      vm_copy.instance_exec(vm_copy, &block)
+    end
+
+    interlock.pop
+    result
+  end
+end
+

data/lib/fOOrth/library/queue_library.rb

@@ -34,13 +34,18 @@ module XfOOrth
     vm.push(self.empty?)
   })
 
+  # [queue] .present? [a_boolean]
+  Queue.create_shared_method('.present?', TosSpec, [], &lambda {|vm|
+    vm.push(!self.empty?)
+  })
+
   # [queue] .length [an_integer]
   Queue.create_shared_method('.length', TosSpec, [], &lambda {|vm|
     vm.push(self.length)
   })
 
   # [queue] .clear []
-  Queue.create_shared_method('.clear', TosSpec, [], &lambda {|vm|
+  Queue.create_shared_method('.clear!', TosSpec, [], &lambda {|vm|
     self.clear
   })
 

data/lib/fOOrth/library/rational_library.rb

@@ -1,90 +1,90 @@
-# coding: utf-8
-
-#* library/rational_library.rb - Numeric support for the fOOrth library.
-module XfOOrth
-
-  #Connect the Rational class to the fOOrth class system.
-  Rational.create_foorth_proxy
-
-  # Some conversion words.
-  # [n d] rational [n/d]
-  VirtualMachine.create_shared_method('rational', VmSpec, [], &lambda {|vm|
-    num,den = popm(2)
-
-    begin
-      push(Rational(num.to_foorth_r, den.to_foorth_r))
-    rescue
-      push(nil)
-    end
-  })
-
-  # Some conversion words.
-  # [n d] rational! [n/d]
-  VirtualMachine.create_shared_method('rational!', VmSpec, [], &lambda {|vm|
-    num,den = popm(2)
-
-    begin
-      push(Rational(num.to_foorth_r, den.to_foorth_r))
-    rescue
-      error "F40: Cannot coerce a #{num.foorth_name}, #{den.foorth_name} to a Rational"
-    end
-  })
-
-  # [err_limit float] .rationalize_to [rational]
-  Numeric.create_shared_method('.rationalize_to', TosSpec, [], &lambda {|vm|
-    err_limit = Float.foorth_coerce(vm.pop)
-
-    vm.push(self.rationalize(err_limit))
-  })
-
-  Complex.create_shared_method('.rationalize_to', TosSpec, [:stub])
-
-  # [rational] .split [numerator, denominator]
-  Rational.create_shared_method('.split', TosSpec, [],
-    &lambda {|vm| vm.push(self.numerator); vm.push(self.denominator); })
-
-  # [a] .to_r [n/d]
-  Object.create_shared_method('.to_r', TosSpec, [], &lambda {|vm|
-    begin
-      vm.push(Rational(self))
-    rescue
-      vm.push(nil)
-    end
-  })
-
-  # [a] .to_r! [n/d]
-  Object.create_shared_method('.to_r!', TosSpec, [], &lambda {|vm|
-    begin
-      vm.push(Rational(self))
-    rescue
-      error "F40: Cannot convert a #{self.foorth_name} to a Rational instance"
-    end
-  })
-
-  # [a_float] .to_r [n/d]
-  Float.create_shared_method('.to_r', TosSpec, [], &lambda {|vm|
-    begin
-      vm.push(self.rationalize)
-    rescue
-      vm.push(nil)
-    end
-  })
-
-  # [a_float] .to_r! [n/d]
-  Float.create_shared_method('.to_r!', TosSpec, [], &lambda {|vm|
-    begin
-      vm.push(self.rationalize)
-    rescue
-      error "F40: Cannot convert a #{self.foorth_name} to a Rational instance"
-    end
-  })
-
-  # [n/d] .numerator [n]
-  Numeric.create_shared_method('.numerator', TosSpec, [],
-    &lambda {|vm| vm.push(self.numerator); })
-
-  # [n/d] .denominator [d]
-  Numeric.create_shared_method('.denominator', TosSpec, [],
-    &lambda {|vm| vm.push(self.denominator); })
-
+# coding: utf-8
+
+#* library/rational_library.rb - Numeric support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Rational class to the fOOrth class system.
+  Rational.create_foorth_proxy
+
+  # Some conversion words.
+  # [n d] rational [n/d]
+  VirtualMachine.create_shared_method('rational', VmSpec, [], &lambda {|vm|
+    num,den = popm(2)
+
+    begin
+      push(Rational(num.to_foorth_r, den.to_foorth_r))
+    rescue
+      push(nil)
+    end
+  })
+
+  # Some conversion words.
+  # [n d] rational! [n/d]
+  VirtualMachine.create_shared_method('rational!', VmSpec, [], &lambda {|vm|
+    num,den = popm(2)
+
+    begin
+      push(Rational(num.to_foorth_r, den.to_foorth_r))
+    rescue
+      error "F40: Cannot coerce a #{num.foorth_name}, #{den.foorth_name} to a Rational"
+    end
+  })
+
+  # [err_limit float] .rationalize_to [rational]
+  Numeric.create_shared_method('.rationalize_to', TosSpec, [], &lambda {|vm|
+    err_limit = Float.foorth_coerce(vm.pop)
+
+    vm.push(self.rationalize(err_limit))
+  })
+
+  Complex.create_shared_method('.rationalize_to', TosSpec, [:stub])
+
+  # [rational] .split [numerator, denominator]
+  Rational.create_shared_method('.split', TosSpec, [],
+    &lambda {|vm| vm.push(self.numerator); vm.push(self.denominator); })
+
+  # [a] .to_r [n/d]
+  Object.create_shared_method('.to_r', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Rational(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  # [a] .to_r! [n/d]
+  Object.create_shared_method('.to_r!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Rational(self))
+    rescue
+      error "F40: Cannot convert a #{self.foorth_name} to a Rational instance"
+    end
+  })
+
+  # [a_float] .to_r [n/d]
+  Float.create_shared_method('.to_r', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(self.rationalize)
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  # [a_float] .to_r! [n/d]
+  Float.create_shared_method('.to_r!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(self.rationalize)
+    rescue
+      error "F40: Cannot convert a #{self.foorth_name} to a Rational instance"
+    end
+  })
+
+  # [n/d] .numerator [n]
+  Numeric.create_shared_method('.numerator', TosSpec, [],
+    &lambda {|vm| vm.push(self.numerator); })
+
+  # [n/d] .denominator [d]
+  Numeric.create_shared_method('.denominator', TosSpec, [],
+    &lambda {|vm| vm.push(self.denominator); })
+
 end

data/lib/fOOrth/library/stack_library.rb

@@ -14,7 +14,7 @@ module XfOOrth
   })
 
   #Clear the Stack object.
-  stack.create_shared_method('.clear', TosSpec, [], &lambda {|vm|
+  stack.create_shared_method('.clear!', TosSpec, [], &lambda {|vm|
     @data.clear
   })
 
@@ -46,6 +46,11 @@ module XfOOrth
     vm.push(@data.empty?)
   })
 
+  #[stack] .present? [a_boolean]
+  stack.create_shared_method('.present?', TosSpec, [], &lambda {|vm|
+    vm.push(!@data.empty?)
+  })
+
   #[stack] .length [an_integer]
   stack.create_shared_method('.length', TosSpec, [], &lambda {|vm|
     vm.push(@data.length)

data/lib/fOOrth/library/string_library.rb

@@ -211,22 +211,34 @@ module XfOOrth
 
   # ['fgh' 'abcdefgh'] .right? [boolean]
   String.create_shared_method('.right?', TosSpec, [],
-    &lambda {|vm| vm.poke(self.end_with?(vm.peek)); })
+    &lambda {|vm| vm.poke(self.end_with?(vm.peek)) })
 
   #Other String Methods
 
   # ['cde' 'abcdefgh'] .contains? [boolean]
   String.create_shared_method('.contains?', TosSpec, [],
-    &lambda {|vm| vm.poke(self.index(vm.peek).to_foorth_b); })
+    &lambda {|vm| vm.poke(self.index(vm.peek).to_foorth_b) })
 
   # ['cde' 'abcdefgh'] .posn [position or nil]
   String.create_shared_method('.posn', TosSpec, [],
-    &lambda {|vm| vm.poke(self.index(vm.peek)); })
+    &lambda {|vm| vm.poke(self.index(vm.peek)) })
 
   # ["a"] .length [n]
   String.create_shared_method('.length', TosSpec, [],
     &lambda {|vm| vm.push(self.length); })
 
+  # ["a"] .empty? [a_boolean]
+  String.create_shared_method('.empty?', TosSpec, [],
+    &lambda {|vm| vm.push(self.empty?) })
+
+  # ["a"] .present? [a_boolean]
+  String.create_shared_method('.present?', TosSpec, [],
+    &lambda {|vm| vm.push(!self.empty?) })
+
+  # ["a"] .clear! [a_boolean]
+  StringBuffer.create_shared_method('.clear!', TosSpec, [],
+    &lambda {|vm| self.clear })
+
   # ["b", a] + ["ba"]; "ba" is a new object, distinct from "b"
   String.create_shared_method('+', NosSpec, [],
     &lambda {|vm| vm.poke((self + vm.peek.to_s).freeze) })
@@ -240,7 +252,7 @@ module XfOOrth
 
   # ["b"*, a] >> ["ab"*]; "ab"* is the same object as "b"*
   StringBuffer.create_shared_method('>>', NosSpec, [],
-    &lambda {|vm| vm.poke(self.prepend(vm.peek.to_s)); })
+    &lambda {|vm| vm.poke(self.prepend(vm.peek.to_s)) })
 
   # ["b", n] * ["bbb..."]
   String.create_shared_method('*', NosSpec, [], &lambda {|vm|
@@ -270,7 +282,7 @@ module XfOOrth
 
   # ["stressed"] .reverse ["desserts"]
   String.create_shared_method('.reverse', TosSpec, [],
-    &lambda {|vm| vm.push(self.to_s.reverse.freeze); })
+    &lambda {|vm| vm.push(self.to_s.reverse.freeze) })
 
   # ["stressed"*] .reverse* [] #Reverse the string in place.
   StringBuffer.create_shared_method('.reverse*', TosSpec, [],
@@ -321,7 +333,7 @@ module XfOOrth
 
   # [a_string] .shell []
   String.create_shared_method('.shell', TosSpec, [], &lambda {|vm|
-    system(self)
+    system(self.chomp + "\n")
   })
 
   # [a_string] .shell_out [a_string]

data/lib/fOOrth/monkey_patch/exceptions.rb

@@ -108,13 +108,9 @@ end
 #Extensions to the RunTimeError to support fOOrth
 class RuntimeError
 
-  #Massage the messages a bit
-  #<br>Endemic Code Smells
-  #* :reek:FeatureEnvy
+  #Massage the messages a bit.
   def message
-    msg = super
-    msg["frozen"] && msg["frozen"] = "protected"
-    msg
+    super.gsub(/frozen/, "protected")
   end
 
 end

data/lib/fOOrth/version.rb

@@ -3,5 +3,5 @@
 #* version.rb - The version string for fOOrth.
 module XfOOrth
   #The version string for fOOrth.
-  VERSION = "0.6.10"
+  VERSION = "0.6.11"
 end

data/tests/compiler/context_tests.rb

@@ -1,177 +1,188 @@
-# coding: utf-8
-
-$exclude_fOOrth_library = true
-require_relative '../../lib/fOOrth'
-gem              'minitest'
-require          'minitest/autorun'
-require          'minitest_visible'
-
-class MockClass
-  def initialize; @data = {}; end
-  def []=(index, value); @data[index] = value; end
-  def map_foorth_shared(index); @data[index]; end
-end
-
-class MockObject
-  def initialize; @data = {}; end
-  def []=(index, value); @data[index] = value; end
-  def map_foorth_exclusive(index); @data[index]; end
-end
-
-#Test the monkey patches applied to the Object class.
-class ContextTester < Minitest::Test
-
-  #Track mini-test progress.
-  include MinitestVisible
-
-  def test_data_store
-    context = XfOOrth::Context.new(45, stuff: 'buy', price: :plenty)
-
-    assert_equal(context.previous, 45)
-    assert_equal(context[:stuff], 'buy')
-    assert_equal(context[:price], :plenty)
-
-    context[:stuff] = 'sell'
-    assert_equal(context[:stuff], 'sell')
-    assert_equal(context[:price], :plenty)
-
-    context[:price] = 9.95
-    assert_equal(context[:stuff], 'sell')
-    assert_equal(context[:price], 9.95)
-  end
-
-  #Test level counting
-  def test_level_tracking
-    context = XfOOrth::Context.new(nil, stuff: 'buy')
-    assert_equal(context.depth, 1)
-
-    context = XfOOrth::Context.new(context, stuff: 'other')
-    assert_equal(context.depth, 2)
-
-    context = XfOOrth::Context.new(context, stuff: 'more')
-    assert_equal(context.depth, 3)
-
-    context = context.previous
-    assert_equal(context.depth, 2)
-
-    context = context.previous
-    assert_equal(context.depth, 1)
-
-    context = context.previous
-    assert_equal(context, nil)
-  end
-
-  def test_the_nesting_of_scopes
-    context = XfOOrth::Context.new(nil, stuff: 'buy')
-    assert_equal(context[:foo], nil)
-    assert_equal(context[:jelly], nil)
-    assert_equal(context[:stuff], 'buy')
-    context[:foo] = 1
-    context[:jelly] = 'donut'
-    assert_equal(context[:jelly], 'donut')
-    assert_equal(context[:stuff], 'buy')
-    assert_equal(context[:foo], 1)
-
-    context = XfOOrth::Context.new(context, stuff: 'other')
-    assert_equal(context[:foo], 1)
-    assert_equal(context[:jelly], 'donut')
-    assert_equal(context[:stuff], 'other')
-    context[:foo] = 2
-    assert_equal(context[:jelly], 'donut')
-    assert_equal(context[:stuff], 'other')
-    assert_equal(context[:foo], 2)
-
-    context = XfOOrth::Context.new(context, stuff: 'more')
-    assert_equal(context[:foo], 2)
-    assert_equal(context[:jelly], 'donut')
-    assert_equal(context[:stuff], 'more')
-    context[:foo] = 3
-    context[:jelly] = 'Berliner'
-    assert_equal(context[:jelly], 'Berliner')
-    assert_equal(context[:stuff], 'more')
-    assert_equal(context[:foo], 3)
-
-    context = context.previous
-    assert_equal(context[:foo], 2)
-    assert_equal(context[:jelly], 'donut')
-    assert_equal(context[:stuff], 'other')
-
-    context = context.previous
-    assert_equal(context[:foo], 1)
-    assert_equal(context[:jelly], 'donut')
-    assert_equal(context[:stuff], 'buy')
-  end
-
-  def test_the_local_mapping_of_symbols
-    context = XfOOrth::Context.new(nil)
-
-    name = 'b'
-    sym = XfOOrth::SymbolMap.add_entry(name)
-    context[sym] = XfOOrth::VmSpec.new(name, sym, [])
-    spec = context.map_with_defaults(name)
-    assert(spec.is_a?(XfOOrth::VmSpec))
-  end
-
-  def test_the_class_mapping_of_symbols
-    mk = MockClass.new
-    context = XfOOrth::Context.new(nil, cls: mk)
-
-    name = '.c'
-    sym = XfOOrth::SymbolMap.add_entry(name)
-    mk[sym] = XfOOrth::TosSpec.new(name, sym, [])
-    spec = context.map_with_defaults(name)
-    assert(spec.is_a?(XfOOrth::TosSpec))
-  end
-
-  def test_the_exclusive_mapping_of_symbols
-    mk = MockObject.new
-    context = XfOOrth::Context.new(nil, obj: mk)
-
-    name = '.d'
-    sym = XfOOrth::SymbolMap.add_entry(name)
-    mk[sym] = XfOOrth::TosSpec.new(name, sym, [])
-    spec = context.map_with_defaults(name)
-    assert(spec.is_a?(XfOOrth::TosSpec))
-  end
-
-  def test_that_it_verifies_sets
-    context = XfOOrth::Context.new(nil, mode: :Execute, ctrl: :colon)
-
-    assert(context.check_set(:mode, [:Execute, :Compile]))
-
-    assert_raises(XfOOrth::XfOOrthError) do
-      context.check_set(:mode, [:Compile, :Deferred])
-    end
-
-    assert(context.check_set(:stuff, [nil]))
-  end
-
-  def test_the_locating_of_the_receiver
-    context = XfOOrth::Context.new(nil, vm: 'vm_sample')
-    assert_equal('vm_sample', context.target)
-
-    context = XfOOrth::Context.new(context, cls: 'cls_sample')
-    assert_equal('cls_sample', context.target)
-
-    context = XfOOrth::Context.new(context, obj: 'obj_sample')
-    assert_equal('obj_sample', context.target)
-
-    context = XfOOrth::Context.new(nil)
-    assert_raises(XfOOrth::XfOOrthError) { context.target }
-  end
-
-  def test_adding_and_removing_local_methods
-    context = XfOOrth::Context.new(nil, vm: 'vm_sample')
-    name = 'lm'
-    sym = XfOOrth::SymbolMap.add_entry(name)
-    spec = context.create_local_method(name, XfOOrth::LocalSpec, [])
-
-    assert_equal(spec, context[sym])
-
-    context.remove_local_method(name)
-
-    assert_equal(nil, context[sym])
-
-  end
-
-end
+# coding: utf-8
+
+$exclude_fOOrth_library = true
+require_relative '../../lib/fOOrth'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class MockClass
+  def initialize; @data = {}; end
+  def []=(index, value); @data[index] = value; end
+  def map_foorth_shared(index); @data[index]; end
+end
+
+class MockObject
+  def initialize; @data = {}; end
+  def []=(index, value); @data[index] = value; end
+  def map_foorth_exclusive(index); @data[index]; end
+end
+
+#Test the monkey patches applied to the Object class.
+class ContextTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_data_store
+    context = XfOOrth::Context.new(45, stuff: 'buy', price: :plenty)
+
+    assert_equal(context.previous, 45)
+    assert_equal(context[:stuff], 'buy')
+    assert_equal(context[:price], :plenty)
+
+    context[:stuff] = 'sell'
+    assert_equal(context[:stuff], 'sell')
+    assert_equal(context[:price], :plenty)
+
+    context[:price] = 9.95
+    assert_equal(context[:stuff], 'sell')
+    assert_equal(context[:price], 9.95)
+  end
+
+  #Test level counting
+  def test_level_tracking
+    context = XfOOrth::Context.new(nil, stuff: 'buy')
+    assert_equal(context.depth, 1)
+
+    context = XfOOrth::Context.new(context, stuff: 'other')
+    assert_equal(context.depth, 2)
+
+    context = XfOOrth::Context.new(context, stuff: 'more')
+    assert_equal(context.depth, 3)
+
+    context = context.previous
+    assert_equal(context.depth, 2)
+
+    context = context.previous
+    assert_equal(context.depth, 1)
+
+    context = context.previous
+    assert_nil(context)
+  end
+
+  def test_the_nesting_of_scopes
+    context = XfOOrth::Context.new(nil, stuff: 'buy')
+    assert_nil(context[:foo])
+    assert_nil(context[:jelly])
+    assert_equal(context[:stuff], 'buy')
+    context[:foo] = 1
+    context[:jelly] = 'donut'
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'buy')
+    assert_equal(context[:foo], 1)
+
+    context = XfOOrth::Context.new(context, stuff: 'other')
+    assert_equal(context[:foo], 1)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'other')
+    context[:foo] = 2
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'other')
+    assert_equal(context[:foo], 2)
+
+    context = XfOOrth::Context.new(context, stuff: 'more')
+    assert_equal(context[:foo], 2)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'more')
+    context[:foo] = 3
+    context[:jelly] = 'Berliner'
+    assert_equal(context[:jelly], 'Berliner')
+    assert_equal(context[:stuff], 'more')
+    assert_equal(context[:foo], 3)
+
+    context = context.previous
+    assert_equal(context[:foo], 2)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'other')
+
+    context = context.previous
+    assert_equal(context[:foo], 1)
+    assert_equal(context[:jelly], 'donut')
+    assert_equal(context[:stuff], 'buy')
+  end
+
+  def test_getting_context_with_a_specific_tag
+    c1 = XfOOrth::Context.new(nil, ctrl: :procedure)
+    c2 = XfOOrth::Context.new(c1, ctrl: :if)
+    c3 = XfOOrth::Context.new(c2, ctrl: :loop)
+
+    assert_equal(c1, c3.get_context_by_ctrl(:procedure))
+    assert_equal(c2, c3.get_context_by_ctrl(:if))
+    assert_equal(c3, c3.get_context_by_ctrl(:loop))
+    assert_raises(XfOOrth::XfOOrthError) { c3.get_context_by_ctrl(:wrong) }
+  end
+
+  def test_the_local_mapping_of_symbols
+    context = XfOOrth::Context.new(nil)
+
+    name = 'b'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    context[sym] = XfOOrth::VmSpec.new(name, sym, [])
+    spec = context.map_with_defaults(name)
+    assert(spec.is_a?(XfOOrth::VmSpec))
+  end
+
+  def test_the_class_mapping_of_symbols
+    mk = MockClass.new
+    context = XfOOrth::Context.new(nil, cls: mk)
+
+    name = '.c'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    mk[sym] = XfOOrth::TosSpec.new(name, sym, [])
+    spec = context.map_with_defaults(name)
+    assert(spec.is_a?(XfOOrth::TosSpec))
+  end
+
+  def test_the_exclusive_mapping_of_symbols
+    mk = MockObject.new
+    context = XfOOrth::Context.new(nil, obj: mk)
+
+    name = '.d'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    mk[sym] = XfOOrth::TosSpec.new(name, sym, [])
+    spec = context.map_with_defaults(name)
+    assert(spec.is_a?(XfOOrth::TosSpec))
+  end
+
+  def test_that_it_verifies_sets
+    context = XfOOrth::Context.new(nil, mode: :Execute, ctrl: :colon)
+
+    assert(context.check_set(:mode, [:Execute, :Compile]))
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      context.check_set(:mode, [:Compile, :Deferred])
+    end
+
+    assert(context.check_set(:stuff, [nil]))
+  end
+
+  def test_the_locating_of_the_receiver
+    context = XfOOrth::Context.new(nil, vm: 'vm_sample')
+    assert_equal('vm_sample', context.target)
+
+    context = XfOOrth::Context.new(context, cls: 'cls_sample')
+    assert_equal('cls_sample', context.target)
+
+    context = XfOOrth::Context.new(context, obj: 'obj_sample')
+    assert_equal('obj_sample', context.target)
+
+    context = XfOOrth::Context.new(nil)
+    assert_raises(XfOOrth::XfOOrthError) { context.target }
+  end
+
+  def test_adding_and_removing_local_methods
+    context = XfOOrth::Context.new(nil, vm: 'vm_sample')
+    name = 'lm'
+    sym = XfOOrth::SymbolMap.add_entry(name)
+    spec = context.create_local_method(name, XfOOrth::LocalSpec, [])
+
+    assert_equal(spec, context[sym])
+
+    context.remove_local_method(name)
+
+    assert_nil(context[sym])
+
+  end
+
+end