fOOrth 0.5.0

data/integration/object_lib_tests.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+require_relative '../lib/fOOrth'
+require_relative 'support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the standard fOOrth library.
+class ObjectLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_that_the_object_class_is_available
+    foorth_equal("Object", [Object])
+  end
+
+  def test_getting_a_things_name
+    foorth_equal("Object .name",      ['Object'])
+    foorth_equal("Class  .name",      ['Class'])
+
+    foorth_equal("Object .new .name", ['Object instance'])
+    foorth_equal("45          .name", ['Fixnum instance'])
+    foorth_equal('"Foobar"    .name', ['String instance'])
+  end
+
+  def test_getting_an_object_as_a_string
+    foorth_equal("4              .to_s", ['4'])
+    foorth_equal("Object         .to_s", ['Object'])
+    foorth_equal("VirtualMachine .to_s", ['VirtualMachine'])
+
+    foorth_equal("4              .strlen", [1])
+  end
+
+end

data/integration/procedure_lib_tests.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+require_relative '../lib/fOOrth'
+require_relative 'support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the standard fOOrth library.
+class ProcedureLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_lambda_basics
+    foorth_equal("{{   }} .name ", ["Procedure instance"])
+  end
+
+  def test_calling_lambdas
+    foorth_equal("1 {{ 99 + }} .call ", [100])
+  end
+
+  def test_creating_a_thread
+    foorth_run('0 var$: $tcat2')
+    foorth_equal('{{ 1 $tcat2 ! }} .start drop 0.01 .sleep $tcat2 @', [1])
+  end
+
+  def test_calling_with
+    foorth_equal('4 {{ self dup + }} .call_with', [8])
+  end
+
+  def test_calling_x_v_and_vx
+    foorth_equal('4 {{ v dup + }} .call_v', [8])
+    foorth_equal('4 {{ x dup + }} .call_x', [8])
+
+    foorth_equal('5 4 {{ v x 2dup + }} .call_vx', [5, 4, 9])
+  end
+end

data/integration/queue_lib_tests.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+
+require_relative '../lib/fOOrth'
+require_relative 'support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the standard fOOrth library.
+class QueueLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_the_queue_class_exists
+    foorth_equal('Queue', [Queue])
+    foorth_equal('Queue .new .class', [Queue])
+  end
+
+  def test_some_queue_operations
+    foorth_run('Queue .new val$: $q')
+    foorth_equal('$q .empty?', [true])
+    foorth_equal('$q .length', [0])
+
+    foorth_equal('5 $q .push', [])
+    foorth_equal('$q .empty?', [false])
+    foorth_equal('$q .length', [1])
+
+    foorth_equal('6 $q .push', [])
+    foorth_equal('$q .empty?', [false])
+    foorth_equal('$q .length', [2])
+
+    foorth_equal('$q .pop'   , [5])
+    foorth_equal('$q .empty?', [false])
+    foorth_equal('$q .length', [1])
+
+    foorth_equal('$q .pop'   , [6])
+    foorth_equal('$q .empty?', [true])
+    foorth_equal('$q .length', [0])
+
+    foorth_equal('5 $q .push', [])
+    foorth_equal('$q .empty?', [false])
+    foorth_equal('$q .length', [1])
+    foorth_equal('$q .clear',  [])
+    foorth_equal('$q .empty?', [true])
+    foorth_equal('$q .length', [0])
+
+    foorth_equal('"A" $q .push $q .pend', ["A"])
+  end
+
+  def test_queues_between_threads
+    foorth_run('Queue .new val$: $q')
+    foorth_run('"Hello" $q .push')
+    foorth_run('{{ $q .pend . }} val$: $b')
+    foorth_output('$b .start 0.01 .sleep', "Hello")
+
+  end
+
+  def test_that_it_catches_underflows
+    foorth_run('Queue .new val$: $q')
+    foorth_raises('$q .pop')
+  end
+
+end

data/integration/stack_lib_tests.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+require_relative 'support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the standard fOOrth library.
+class StackLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_the_stack_class_exists
+    foorth_equal('Stack',             [XfOOrth::XfOOrth_Stack])
+    foorth_equal('Stack .name',       ['Stack'])
+    foorth_equal('Stack .new .class', [XfOOrth::XfOOrth_Stack])
+    foorth_equal('Stack .new .name',  ['Stack instance'])
+  end
+
+  def test_some_stack_operations
+    foorth_run('Stack .new val$: $s')
+    foorth_equal('$s .empty?', [true])
+    foorth_equal('$s .length', [0])
+
+    foorth_equal('5 $s .push', [])
+    foorth_equal('$s .peek',   [5])
+    foorth_equal('$s .empty?', [false])
+    foorth_equal('$s .length', [1])
+
+    foorth_equal('6 $s .push', [])
+    foorth_equal('$s .peek',   [6])
+    foorth_equal('$s .empty?', [false])
+    foorth_equal('$s .length', [2])
+
+    foorth_equal('$s .pop',    [6])
+    foorth_equal('$s .peek',   [5])
+    foorth_equal('$s .empty?', [false])
+    foorth_equal('$s .length', [1])
+
+    foorth_equal('$s .pop',    [5])
+    foorth_equal('$s .empty?', [true])
+    foorth_equal('$s .length', [0])
+
+  end
+
+  def test_that_it_catches_underflows
+    foorth_run('Stack .new val$: $s')
+
+    foorth_raises('$s .pop')
+    foorth_raises('$s .peek')
+
+  end
+
+  def test_stack_clear
+    foorth_run('Stack .new val$: $s')
+
+    foorth_run('42 $s .push')
+    foorth_equal('$s .empty?', [false])
+    foorth_equal('$s .peek', [42])
+
+    foorth_run('$s .clear')
+
+    foorth_equal('$s .empty?', [true])
+    foorth_raises('$s .peek')
+  end
+
+end

data/integration/standard_lib_tests.rb

@@ -0,0 +1,208 @@
+# coding: utf-8
+
+require_relative '../lib/fOOrth'
+require_relative 'support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the standard fOOrth library.
+class StandardLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_basic_constants
+    refute(Thread.current[:vm].nil?)
+
+    foorth_equal("self",      [XfOOrth::VirtualMachine.vm])
+    foorth_equal("true",      [true])
+    foorth_equal("false",     [false])
+    foorth_equal("nil",       [nil])
+
+    foorth_equal("true  .class .to_s", ['True'])
+    foorth_equal("false .class .to_s", ['False'])
+    foorth_equal("nil   .class .to_s", ['Nil'])
+
+    foorth_equal("epsilon",   [Float::EPSILON])
+    foorth_equal("infinity",  [Float::INFINITY]) #and beyond...
+    foorth_equal("-infinity", [-Float::INFINITY])
+    foorth_equal("max_float", [Float::MAX])
+    foorth_equal("min_float", [Float::MIN])
+    foorth_equal("nan",       [Float::NAN])
+  end
+
+  def test_stack_manipulation
+    foorth_equal("1 2", [1, 2])
+
+    foorth_equal("1 2 drop", [1])
+    foorth_raises("drop")
+
+    foorth_equal("33 dup", [33,33])
+    foorth_raises("dup")
+
+    foorth_equal("false ?dup", [false])
+    foorth_equal("nil ?dup", [nil])
+    foorth_equal('"" ?dup', ["", ""])
+    foorth_equal("true  ?dup", [true, true])
+    foorth_equal('"A" ?dup', ["A", "A"])
+    foorth_equal("1 ?dup", [1,1])
+    foorth_raises("?dup")
+
+    foorth_equal("1 2 swap", [2,1])
+    foorth_raises("1 swap")
+    foorth_raises("swap")
+
+    foorth_equal("1 2 3 rot", [2,3,1])
+
+    foorth_equal("1 2 over", [1,2,1])
+
+    foorth_equal("1 2 3 1 pick", [1,2,3,3])
+    foorth_equal("1 2 3 2 pick", [1,2,3,2])
+    foorth_equal("1 2 3 3 pick", [1,2,3,1])
+    foorth_raises("1 2 3 4 pick")
+    foorth_raises("1 2 3 -4 pick")
+    foorth_raises('1 2 3 "apple" pick')
+
+    foorth_equal("1 2 nip", [2])
+    foorth_raises("1 nip")
+
+    foorth_equal("1 2 tuck", [2,1,2])
+    foorth_raises("1 tuck")
+    foorth_raises("tuck")
+  end
+
+  def test_the_double_stack_ops
+    foorth_equal('1 2 2drop', [])
+    foorth_equal('1 2 2dup', [1,2,1,2])
+
+    foorth_raises('1 2drop')
+    foorth_raises('1 2dup')
+  end
+
+  def test_for_the_bored_identity
+    foorth_equal("33 33 identical?", [true])
+    foorth_equal("33 33 distinct?", [false])
+
+    foorth_equal('"33" "33" identical?', [false])
+    foorth_equal('"33" "33" distinct?', [true])
+
+    foorth_equal('"33" dup  identical?', [true])
+    foorth_equal('"33" dup  distinct?', [false])
+
+  end
+
+  def test_dyadic_error_recovery
+    #Insufficient parameters.
+    foorth_equal('try       5 +   catch end', [])
+
+    #Stub action.
+    foorth_equal('try false 5 +   catch end', [])
+
+    #Bad parameters.
+    foorth_equal('try 5 false >   catch end', [])
+    foorth_equal('try 5 false <   catch end', [])
+    foorth_equal('try 5 false >=  catch end', [])
+    foorth_equal('try 5 false <=  catch end', [])
+    foorth_equal('try 5 false <=> catch end', [])
+    foorth_equal('try 5 false +   catch end', [])
+    foorth_equal('try 5 false -   catch end', [])
+    foorth_equal('try 5 false *   catch end', [])
+    foorth_equal('try 5 false **  catch end', [])
+    foorth_equal('try 5 false /   catch end', [])
+    foorth_equal('try 5 false mod catch end', [])
+
+    foorth_equal('try now false >   catch end', [])
+    foorth_equal('try now false <   catch end', [])
+    foorth_equal('try now false >=  catch end', [])
+    foorth_equal('try now false <=  catch end', [])
+    foorth_equal('try now false <=> catch end', [])
+    foorth_equal('try now false +   catch end', [])
+    foorth_equal('try now false -   catch end', [])
+    foorth_equal('try now false format catch end', [])
+
+    foorth_equal('try 10 .to_duration false >   catch end', [])
+    foorth_equal('try 10 .to_duration false <   catch end', [])
+    foorth_equal('try 10 .to_duration false >=  catch end', [])
+    foorth_equal('try 10 .to_duration false <=  catch end', [])
+    foorth_equal('try 10 .to_duration false <=> catch end', [])
+    foorth_equal('try 10 .to_duration false +   catch end', [])
+    foorth_equal('try 10 .to_duration false -   catch end', [])
+    foorth_equal('try 10 .to_duration false *   catch end', [])
+    foorth_equal('try 10 .to_duration false /   catch end', [])
+    foorth_equal('try 10 .to_duration f"%Z"     catch end', [])
+
+    foorth_equal('try 11 false and catch end', [])
+    foorth_equal('try 11 false or  catch end', [])
+    foorth_equal('try 11 false xor catch end', [])
+    foorth_equal('try 11 false <<  catch end', [])
+    foorth_equal('try 11 false >>  catch end', [])
+
+    foorth_equal('try 11 false max catch end', [])
+    foorth_equal('try 11 false min catch end', [])
+
+
+    foorth_equal('try 11  false format catch end', [])
+    foorth_equal('try "a" false *      catch end', [])
+
+  end
+
+  def test_some_logical_and
+    foorth_equal("false false &&", [false])
+    foorth_equal("false true  &&", [false])
+    foorth_equal("true  false &&", [false])
+    foorth_equal("true  true  &&", [true ])
+
+    foorth_equal("nil   false &&", [false])
+    foorth_equal("nil   true  &&", [false])
+    foorth_equal("true  nil   &&", [false])
+    foorth_equal("42    true  &&", [true ])
+  end
+
+  def test_some_logical_or
+    foorth_equal("false false ||", [false])
+    foorth_equal("false true  ||", [true ])
+    foorth_equal("true  false ||", [true ])
+    foorth_equal("true  true  ||", [true ])
+
+    foorth_equal("nil   false ||", [false])
+    foorth_equal("nil   true  ||", [true ])
+    foorth_equal("true  nil   ||", [true ])
+    foorth_equal("42    true  ||", [true ])
+  end
+
+  def test_some_logical_xor
+    foorth_equal("false false ^^", [false])
+    foorth_equal("false true  ^^", [true ])
+    foorth_equal("true  false ^^", [true ])
+    foorth_equal("true  true  ^^", [false])
+
+    foorth_equal("nil   false ^^", [false])
+    foorth_equal("nil   true  ^^", [true ])
+    foorth_equal("true  nil   ^^", [true ])
+    foorth_equal("42    true  ^^", [false])
+  end
+
+  def test_some_logical_not
+    foorth_equal("false not", [true ])
+    foorth_equal("true  not", [false])
+  end
+
+  def test_is_nil
+    foorth_equal("false nil=", [false])
+    foorth_equal("true  nil=", [false])
+    foorth_equal("42    nil=", [false])
+    foorth_equal("nil   nil=", [true])
+  end
+
+  def test_is_not_nil
+    foorth_equal("false nil<>", [true])
+    foorth_equal("true  nil<>", [true])
+    foorth_equal("42    nil<>", [true])
+    foorth_equal("nil   nil<>", [false])
+  end
+
+
+end

data/integration/stdio_lib_tests.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+require_relative './support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the standard fOOrth library.
+class StdioLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_the_dot
+    foorth_output('4 .', "4")
+    foorth_output('-4 .', "-4")
+    foorth_output('"test" .', "test")
+    foorth_output('Object .name .', "Object")
+  end
+
+  def test_the_dot_quote
+    foorth_output('."test"', "test")
+  end
+
+  def test_the_dot_cr
+    foorth_output('cr', "\n")
+  end
+
+  def test_the_space
+    foorth_output('space', " ")
+  end
+
+  def test_the_spaces
+    foorth_output('1 spaces', " ")
+    foorth_output('2 spaces', "  ")
+    foorth_output('0 spaces', "")
+    foorth_raises('"apple"  spaces')
+  end
+
+  def test_the_emit
+    foorth_output(' 65 .emit', "A")
+    foorth_output('126 .emit', "~")
+
+    foorth_utf8_output('255 .emit', [195, 191])
+
+    foorth_output(' "A123" .emit', "A")
+    foorth_raises('1+1i .emit')
+  end
+
+end