fOOrth 0.5.0

data/tests/compiler/file_source_test_one.txt

@@ -0,0 +1 @@
+abc

data/tests/compiler/file_source_test_three.txt

@@ -0,0 +1,3 @@
+a
+b
+c

data/tests/compiler/file_source_test_two.txt

@@ -0,0 +1,3 @@
+a
+b
+c

data/tests/compiler/file_source_tests.rb

@@ -0,0 +1,130 @@
+# 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 FileSourceTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  #Test that we can read from a single line string
+  def test_single_line_file
+    source = XfOOrth::FileSource.new("tests/compiler/file_source_test_one.txt")
+
+    assert_equal(source.get, 'a')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'b')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'c')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+
+    source.close
+  end
+
+  #Test that we can read from a multi-line string
+  def test_multi_line_string
+    source = XfOOrth::FileSource.new("tests/compiler/file_source_test_two.txt")
+
+    assert_equal(source.get, 'a')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'b')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'c')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+
+    source.close
+  end
+
+  #Test that we can read from a multi-line string again
+  def test_multi_line_string_again
+    source = XfOOrth::FileSource.new("tests/compiler/file_source_test_three.txt")
+
+    assert_equal(source.get, 'a')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'b')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'c')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+
+    source.close
+  end
+
+  #Test closing part way through the source.
+  def test_closing
+    source = XfOOrth::FileSource.new("tests/compiler/file_source_test_one.txt")
+
+    assert_equal(source.get, 'a')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    source.close
+
+    assert(source.eoln?)
+    assert(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+  end
+
+end

data/tests/compiler/mode_tests.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+$exclude_fOOrth_library = true
+require_relative '../../lib/fOOrth'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class CompilerModeTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_mode_nesting
+    #Get the virtual machine.
+    vm = Thread.current[:vm]
+    vm.interpreter_reset
+    vm.compiler_reset
+
+    #Test the baseline assumptions.
+    assert_equal(vm.context.depth, 1)
+
+    #Nest in by one level.
+    vm.nest_mode("", "[")
+    assert_equal(vm.context.depth, 2)
+
+    #Back off nesting by one level.
+    vm.unnest_mode("", ["["])
+    assert_equal(vm.context.depth, 1)
+  end
+
+  def test_ill_nesting
+    #Get the virtual machine.
+    vm = Thread.current[:vm]
+    vm.interpreter_reset
+    vm.compiler_reset
+
+    #Nest in by one level.
+    vm.nest_mode("", "[")
+
+    #Back off nesting by one level with wrong tag.
+    assert_raises(XfOOrth::XfOOrthError) { vm.unnest_mode("", ["{"]) }
+  end
+
+end

data/tests/compiler/parser_tests.rb

@@ -0,0 +1,116 @@
+# 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 ParserTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  #Test simple parsing into words.
+  def test_parsing_words_raw
+    test_string = '2 3 + .'
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word_raw, '2')
+    assert_equal(parser.get_word_raw, '3')
+    assert_equal(parser.get_word_raw, '+')
+    assert_equal(parser.get_word_raw, '.')
+    assert_equal(parser.get_word_raw, nil)
+  end
+
+  #Test parsing strings.
+  def test_parsing_strings
+    test_string = '."Testing 1 2 3"'
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word_raw, '."')
+    assert_equal(parser.get_string, 'Testing 1 2 3')
+  end
+
+  #Test parsing open ended strings.
+  def test_parsing_open_ended_strings
+    test_string = '."Testing 1 2 3' + "\n"
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word_raw, '."')
+    assert_equal(parser.get_string, 'Testing 1 2 3')
+  end
+
+  #Test parsing strings some more.
+  def test_parsing_strings_breaks
+    test_string = '."Testing 1 ' + "\\" + "\n" + '2 3"'
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word_raw, '."')
+    assert_equal(parser.get_string, 'Testing 1 2 3')
+  end
+
+  #Test parsing nested comments.
+  def test_parsing_comments
+    test_string = '1 2 (Now we add them!) + .'
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word_raw, '1')
+    assert_equal(parser.get_word_raw, '2')
+    assert_equal(parser.get_word_raw, '(')
+    parser.skip_over_comment
+    assert_equal(parser.get_word_raw, '+')
+    assert_equal(parser.get_word_raw, '.')
+    assert_equal(parser.get_word_raw, nil)
+  end
+
+  #Test parsing ill-nested comments.
+  def test_parsing_bad_comments
+    test_string = '1 2 (Now we add them! + .'
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word_raw, '1')
+    assert_equal(parser.get_word_raw, '2')
+    assert_equal(parser.get_word_raw, '(')
+
+    assert_raises(XfOOrth::XfOOrthError) do
+      parser.skip_over_comment
+    end
+  end
+
+  #Test parsing C++ style comments.
+  def test_parsing_cpp_comments
+    test_string = '1 2 //Now we add them!' + "\n" + '+ .'
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word_raw, '1')
+    assert_equal(parser.get_word_raw, '2')
+    assert_equal(parser.get_word_raw, '//')
+    parser.skip_to_eoln
+    assert_equal(parser.get_word_raw, '+')
+    assert_equal(parser.get_word_raw, '.')
+    assert_equal(parser.get_word_raw, nil)
+  end
+
+  #Test parsing of words.
+  def test_parse_word
+    test_string = '1 2 //Now we add them!' + "\n" + '(Now add!) + (Now print!) .'
+    source = XfOOrth::StringSource.new(test_string)
+    parser = XfOOrth::Parser.new(source)
+
+    assert_equal(parser.get_word, '1')
+    assert_equal(parser.get_word, '2')
+    assert_equal(parser.get_word, '+')
+    assert_equal(parser.get_word, '.')
+    assert_equal(parser.get_word, nil)
+  end
+
+end

data/tests/compiler/spec_tests.rb

@@ -0,0 +1,113 @@
+# 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 SpecTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  #Test simple parsing into words.
+  def test_that_abstract_is_abstract_dammit
+    assert_raises(NoMethodError) do
+      AbstractWordSpec("fred", :freddy, [])
+    end
+  end
+
+  def test_vm_spec
+    spec = XfOOrth::VmSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("vm.freddy(vm); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_tos_spec
+    spec = XfOOrth::TosSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("vm.pop.freddy(vm); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_nos_spec
+    spec = XfOOrth::NosSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("vm.swap_pop.freddy(vm); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_self_spec
+    spec = XfOOrth::SelfSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("self.freddy(vm); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_class_spec
+    spec = XfOOrth::ClassSpec.new(Object, nil, [:class])
+
+    assert_equal("vm.push(Object); ", spec.builds)
+    assert_equal(Object, spec.new_class)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:class))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_instance_var_spec
+    spec = XfOOrth::InstanceVarSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("vm.push(@freddy); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_thread_var_spec
+    spec = XfOOrth::ThreadVarSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("vm.push(vm.data[:freddy]); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_global_var_spec
+    spec = XfOOrth::GlobalVarSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("vm.push($freddy); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_local_spec
+    spec = XfOOrth::LocalSpec.new("fred", :freddy, [:foo])
+
+    assert_equal("vm.context[:freddy].does.call(vm); ", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+  def test_macro_spec
+    spec = XfOOrth::MacroSpec.new("fred", :freddy, [:foo, "macro contents"])
+
+    assert_equal("macro contents", spec.builds)
+    assert_instance_of(Proc, spec.does)
+    assert(spec.has_tag?(:foo))
+    refute(spec.has_tag?(:bar))
+  end
+
+end

data/tests/compiler/string_source_tests.rb

@@ -0,0 +1,128 @@
+# 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 StringSourceTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  #Test that we can read from a single line string
+  def test_single_line_string
+    test_string = "abc"
+    source = XfOOrth::StringSource.new(test_string)
+
+    assert_equal(source.get, 'a')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'b')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'c')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+  end
+
+  #Test that we can read from a multi-line string
+  def test_multi_line_string
+    test_string = "a\nb\nc"
+    source = XfOOrth::StringSource.new(test_string)
+
+    assert_equal(source.get, 'a')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'b')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'c')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+  end
+
+  #Test that we can read from a multi-line string again
+  def test_multi_line_string_again
+    test_string = "a\nb\nc\n"
+    source = XfOOrth::StringSource.new(test_string)
+
+    assert_equal(source.get, 'a')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'b')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, 'c')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, ' ')
+    assert(source.eoln?)
+    refute(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+  end
+
+  #Test closing part way through the source.
+  def test_closing
+    test_string = "ABCDEFG - Eric the Half a Bee!"
+    source = XfOOrth::StringSource.new(test_string)
+
+    assert_equal(source.get, 'A')
+    refute(source.eoln?)
+    refute(source.eof?)
+
+    source.close
+
+    assert(source.eoln?)
+    assert(source.eof?)
+
+    assert_equal(source.get, nil)
+    assert(source.eoln?)
+    assert(source.eof?)
+  end
+
+end