fOOrth 0.5.0

data/integration/class_lib_tests.rb

@@ -0,0 +1,116 @@
+# 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 ClassLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_that_the_class_class_is_available
+    foorth_equal("Class", [Class])
+  end
+
+  def test_that_we_can_tell_classes_from_non_classes
+    foorth_equal("Class  .is_class?",      [true])
+    foorth_equal("Object .is_class?",      [true])
+    foorth_equal("Object .new .is_class?", [false])
+
+    foorth_equal("Numeric .is_class?",     [true])
+    foorth_equal("42      .is_class?",     [false])
+  end
+
+  def test_that_we_can_find_the_class_of_a_thing
+    foorth_equal("Class       .class",     [Class])
+    foorth_equal("Object      .class",     [Class])
+
+    foorth_equal("Object .new .class",     [Object])
+    foorth_equal("42          .class",     [Fixnum])
+    foorth_equal('"foobar"    .class',     [String])
+  end
+
+  def test_that_we_can_find_the_parent_of_a_class
+    foorth_equal("Class     .parent_class",   [Object])
+    foorth_equal("Object    .parent_class",   [nil])
+
+    foorth_run('class: TTWCFTPC')
+    foorth_equal("TTWCFTPC .parent_class", [Object])
+  end
+
+  def test_the_creation_of_a_class
+    foorth_equal("class: T1",        [])
+
+    foorth_equal("T1",               [XfOOrth::XfOOrth_T1])
+    foorth_equal("T1 .parent_class", [Object])
+    foorth_equal("T1 .name",         ['T1'])
+    foorth_equal("T1 .new .name",    ['T1 instance'])
+  end
+
+  def test_deferred_class_creation
+    foorth_run(" true if class: T1B then ")
+    foorth_equal("T1B .name", ["T1B"])
+  end
+
+  def test_deferred_subclass_creation
+    foorth_run(" true if Object .subclass: T1C then ")
+    foorth_equal("T1C .name", ["T1C"])
+  end
+
+  def test_the_creation_of_a_sub_class
+    foorth_equal("class: T2",        [])
+    foorth_equal("T2 .subclass: T3", [])
+
+    foorth_equal("T3",               [XfOOrth::XfOOrth_T3])
+    foorth_equal("T3 .parent_class", [XfOOrth::XfOOrth_T2])
+    foorth_equal("T3 .name",         ['T3'])
+    foorth_equal("T3 .new .name",    ['T3 instance'])
+  end
+
+  def test_creating_an_init_method
+    foorth_equal("class: T4", [])
+    foorth_equal("T4 .: .init 2 4 6 8 ;", [])
+
+    foorth_equal("T4 .new .name", [2, 4, 6, 8, 'T4 instance'])
+  end
+
+  def test_creating_an_instance_var
+    foorth_equal("class: T5", [])
+    foorth_equal("T5 .: .init var@: @a ;", [])
+    foorth_equal("T5 .: .a@ @a @ ;", [])
+
+    foorth_equal("10 T5 .new .a@", [10])
+  end
+
+  def test_creating_an_accessor
+    foorth_equal("class: T6", [])
+    foorth_equal("T6 .: .init var@: @a ;", [])
+    foorth_equal("T6 .: .a@ @a @ ;", [])
+    foorth_equal("T6 .: .a! @a ! ;", [])
+
+    foorth_equal("nil T6 .new dup 100 swap .a! .a@", [100])
+  end
+
+  def test_creating_an_instance_val
+    foorth_equal("class: T7", [])
+    foorth_equal("T7 .: .init val@: @a ;", [])
+    foorth_equal("T7 .: .a@ @a ;", [])
+
+    foorth_equal("10 T7 .new .a@", [10])
+  end
+
+  def test_the_checking_of_classes
+    foorth_equal('12   Numeric .check', [12])
+    foorth_equal('"12" Numeric .check', [nil])
+
+    foorth_equal('12   Numeric .check!', [12])
+    foorth_raises('"12" Numeric .check!')
+  end
+
+end

data/integration/clone_lib_tests.rb

@@ -0,0 +1,108 @@
+# 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 CloneLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_some_cloning_around
+    foorth_equal("33 clone", [33,33])
+    foorth_equal("33 .clone", [33])
+
+    foorth_equal("33 clone identical?", [true])
+    foorth_equal("33 clone distinct?", [false])
+
+    foorth_equal('"33" clone identical?', [false])
+    foorth_equal('"33" clone distinct?', [true])
+
+    foorth_equal('"33" dup .clone identical?', [false])
+    foorth_equal('"33" dup .clone distinct?', [true])
+
+    foorth_equal('[ "33" ] clone distinct?', [true])
+    foorth_equal('[ "33" ] clone @ swap @ distinct?', [true])
+
+  end
+
+  def test_some_clone_exclusion
+    foorth_run('class: Tscx')
+    foorth_run('Tscx .: .init "a" val@: @a "b" val@: @b ;')
+    foorth_run('Tscx .: .a @a ;')
+    foorth_run('Tscx .: .b @b ;')
+    foorth_run('Tscx .: .clone_exclude [ "@b" ] ;')
+    foorth_run('Tscx .new val$: $tscx1')
+    foorth_run('$tscx1 .clone val$: $tscx2')
+
+    foorth_equal('$tscx1 .clone_exclude', [["@b"]])
+
+    foorth_equal('$tscx1 .a', ["a"])
+    foorth_equal('$tscx1 .b', ["b"])
+    foorth_equal('$tscx2 .a', ["a"])
+    foorth_equal('$tscx2 .b', ["b"])
+
+    foorth_run('$tscx1 .a "1" <<')
+    foorth_run('$tscx1 .b "1" <<')
+
+    foorth_equal('$tscx1 .a', ["a1"])
+    foorth_equal('$tscx1 .b', ["b1"])
+    foorth_equal('$tscx2 .a', ["a"])
+    foorth_equal('$tscx2 .b', ["b1"])
+
+  end
+
+  def test_array_clone_exclusion
+    foorth_run('[ "a" "b" ] val$: $tacx1')
+    foorth_run('$tacx1 .:: .clone_exclude [ 1 ] ;')
+    foorth_run('$tacx1 .clone val$: $tacx2')
+
+    foorth_equal('$tacx1 .clone_exclude', [[1]])
+    foorth_equal('$tacx2 .clone_exclude', [[1]])
+
+    foorth_equal('$tacx1', [["a", "b"]])
+    foorth_equal('$tacx2', [["a", "b"]])
+
+    foorth_run('0 $tacx1 .[]@ "1" <<')
+    foorth_run('1 $tacx1 .[]@ "1" <<')
+
+    foorth_equal('$tacx1', [["a1", "b1"]])
+    foorth_equal('$tacx2', [["a", "b1"]])
+  end
+
+  def test_hash_clone_exclusion
+    foorth_run('{ 0 "a" -> 1 "b" -> } val$: $thcx1')
+    foorth_run('$thcx1 .:: .clone_exclude [ 1 ] ;')
+    foorth_run('$thcx1 .clone val$: $thcx2')
+
+    foorth_equal('$thcx1 .clone_exclude', [[1]])
+    foorth_equal('$thcx2 .clone_exclude', [[1]])
+
+    foorth_equal('$thcx1', [{0=>"a", 1=>"b"}])
+    foorth_equal('$thcx2', [{0=>"a", 1=>"b"}])
+
+    foorth_run('0 $thcx1 .[]@ "1" <<')
+    foorth_run('1 $thcx1 .[]@ "1" <<')
+
+    foorth_equal('$thcx1', [{0=>"a1", 1=>"b1"}])
+    foorth_equal('$thcx2', [{0=>"a", 1=>"b1"}])
+  end
+
+  def test_some_copying_too
+    foorth_equal("33 copy", [33,33])
+    foorth_equal("33 .copy", [33])
+
+    foorth_equal('"33" copy identical?', [false])
+    foorth_equal('"33" copy distinct?', [true])
+
+    foorth_equal('[ "33" ] copy distinct?', [true])
+    foorth_equal('[ "33" ] copy @ swap @ distinct?', [false])
+  end
+
+end

data/integration/comparison_tests.rb

@@ -0,0 +1,132 @@
+# 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 ComparisonTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_greater_than
+   foorth_raises("Object .new 4 > ")
+  end
+
+  def test_max_and_min
+    foorth_equal("4    2   max", [4])
+
+    foorth_equal("4    2   min", [2])
+
+    foorth_equal('"4" "2"  max', ["4"])
+    foorth_equal('"4" "2"  min', ["2"])
+  end
+
+  def test_more_holistically
+    foorth_equal("[ 2 4 -2 1/2 555 8 -33 17 ] val$: $tmw", [])
+
+    foorth_equal("infinity  $tmw .each{{ v min }}  ", [-33])
+    foorth_equal("-infinity $tmw .each{{ v max }}  ", [555])
+  end
+
+  def test_greater_than
+    foorth_equal('4       4       >  ', [false])
+    foorth_equal('4       5       >  ', [false])
+    foorth_equal('5       4       >  ', [true])
+
+    foorth_equal('"4"       "4"   >  ', [false])
+    foorth_equal('"4"       4     >  ', [false])
+    foorth_equal('"4"       "5"   >  ', [false])
+    foorth_equal('"4"       5     >  ', [false])
+    foorth_equal('"5"       "4"   >  ', [true])
+    foorth_equal('"5"       4     >  ', [true])
+  end
+
+  def test_less_than
+    foorth_equal('4       4       <  ', [false])
+    foorth_equal('4       5       <  ', [true])
+    foorth_equal('5       4       <  ', [false])
+
+    foorth_equal('"4"       "4"   <  ', [false])
+    foorth_equal('"4"       4     <  ', [false])
+    foorth_equal('"4"       "5"   <  ', [true])
+    foorth_equal('"4"       5     <  ', [true])
+    foorth_equal('"5"       "4"   <  ', [false])
+    foorth_equal('"5"       4     <  ', [false])
+  end
+
+  def test_greater_or_equal
+    foorth_equal('4       4       >= ', [true])
+    foorth_equal('4       5       >= ', [false])
+    foorth_equal('5       4       >= ', [true])
+
+    foorth_equal('"4"       "4"   >= ', [true])
+    foorth_equal('"4"       4     >= ', [true])
+    foorth_equal('"4"       "5"   >= ', [false])
+    foorth_equal('"4"       5     >= ', [false])
+    foorth_equal('"5"       "4"   >= ', [true])
+    foorth_equal('"5"       4     >= ', [true])
+  end
+
+  def test_less_or_equal
+    foorth_equal('4       4       <= ', [true])
+    foorth_equal('4       5       <= ', [true])
+    foorth_equal('5       4       <= ', [false])
+
+    foorth_equal('"4"       "4"   <= ', [true])
+    foorth_equal('"4"       4     <= ', [true])
+    foorth_equal('"4"       "5"   <= ', [true])
+    foorth_equal('"4"       5     <= ', [true])
+    foorth_equal('"5"       "4"   <= ', [false])
+    foorth_equal('"5"       4     <= ', [false])
+  end
+
+  def test_the_compare_operator
+    foorth_equal('4       4       <=>', [0])
+    foorth_equal('4       5       <=>', [-1])
+    foorth_equal('5       4       <=>', [1])
+
+    foorth_equal('"4"       "4"   <=>', [0])
+    foorth_equal('"4"       4     <=>', [0])
+    foorth_equal('"4"       "5"   <=>', [-1])
+    foorth_equal('"4"       5     <=>', [-1])
+    foorth_equal('"5"       "4"   <=>', [1])
+    foorth_equal('"5"       4     <=>', [1])
+  end
+
+  def test_some_comparisons_with_zero
+    foorth_equal('-2       0=  ', [false])
+    foorth_equal('0        0=  ', [true])
+    foorth_equal('4        0=  ', [false])
+
+    foorth_equal('-4       0<> ', [true])
+    foorth_equal('0        0<> ', [false])
+    foorth_equal('5        0<> ', [true])
+
+    foorth_equal('-1       0>  ', [false])
+    foorth_equal('0        0>  ', [false])
+    foorth_equal('4        0>  ', [true])
+
+    foorth_equal('4        0<  ', [false])
+    foorth_equal('-5       0<  ', [true])
+    foorth_equal('0        0<  ', [false])
+
+    foorth_equal('4        0>= ', [true])
+    foorth_equal('-5       0>= ', [false])
+    foorth_equal('0        0>= ', [true])
+
+    foorth_equal('-4       0<= ', [true])
+    foorth_equal('0        0<= ', [true])
+    foorth_equal('4        0<= ', [false])
+
+    foorth_equal('0        0<=>', [0])
+    foorth_equal('-5       0<=>', [-1])
+    foorth_equal('4        0<=>', [1])
+  end
+
+end

data/integration/compile_lib_tests.rb

@@ -0,0 +1,190 @@
+# coding: utf-8
+
+require_relative '../lib/fOOrth'
+require_relative 'support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the fOOrth compile library.
+class CompileLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_creating_simple_words
+    foorth_equal(': dbl dup + ; 4 dbl', [8])
+    foorth_equal('9 dbl', [18])
+  end
+
+  def test_creating_immediate_words
+    foorth_equal('!: five 5 ;', [])
+    foorth_equal('five', [5])
+
+    foorth_equal(': six five 6 ;', [5])
+    foorth_equal('six', [6])
+  end
+
+  def test_simple_word_override
+    foorth_equal(': foo 3 * ; 4 foo', [12])
+    foorth_equal('5 foo', [15])
+    foorth_equal(': foo 4 * ; 4 foo', [16])
+    foorth_equal('5 foo', [20])
+  end
+
+  def test_creating_methods
+    foorth_equal('Numeric .: .dbl self dup + ; 4 .dbl', [8])
+    foorth_equal('9 .dbl', [18])
+  end
+
+  def test_methods_override
+    foorth_equal('Numeric .: .foo self 3 * ; 4 .foo', [12])
+    foorth_equal('5 .foo', [15])
+    foorth_equal('Numeric .: .foo self 4 * ; 4 .foo', [16])
+    foorth_equal('5 .foo', [20])
+  end
+
+  def test_words_with_local_vars
+    foorth_equal(': lvt1 dup var: lv lv @ * ;' , [])
+    foorth_equal('10 lvt1 ' , [100])
+
+    foorth_equal(': lvt2 val: lv lv  10 * ;' , [])
+    foorth_equal('10 lvt2 ' , [100])
+  end
+
+  def test_private_methods
+    foorth_equal('class: PMTC', [])
+    foorth_equal('PMTC .: ~t10 10 * ; ', [])
+    foorth_equal('PMTC .: .t11  dup ~t10 + ; ', [])
+    foorth_equal('5 PMTC .new   .t11  ', [55])
+  end
+
+  def test_some_invalid_names
+    foorth_run('class: TSIN')
+
+    foorth_raises('TSIN .: Bad ."wow" ; ')
+    foorth_raises('TSIN .: @ad ."wow" ; ')
+    foorth_raises('TSIN .: $ad ."wow" ; ')
+    foorth_raises('TSIN .: #ad ."wow" ; ')
+
+  end
+
+  def test_spec_mapping
+    foorth_run('class:  TempClass')
+    foorth_run('TempClass .: .hi_aaa   42 ; ')
+
+    foorth_run('class:  TempOther')
+    foorth_run('TempOther .: .hi_aaa   69 ; ')
+
+    foorth_equal('TempClass .new .hi_aaa', [42] )
+    foorth_equal('TempOther .new .hi_aaa', [69] )
+
+    foorth_run('TempClass .: + 42 + ; ')
+    foorth_run('TempOther .: + 69 + ; ')
+
+    foorth_equal('TempClass .new 10 + ', [52] )
+    foorth_equal('TempOther .new 10 + ', [79] )
+
+    foorth_run('TempClass .: add 42 + ; ')
+    foorth_run('TempOther .: add 69 + ; ')
+
+    foorth_equal('TempClass .new 10 add ', [52] )
+    foorth_equal('TempOther .new 10 add ', [79] )
+
+    foorth_run(': booboo 5 ;')
+    foorth_raises('TempClass .: booboo 6 ;')
+
+    foorth_run('TempClass .: bambam 6 ;')
+    foorth_raises(': bambam 5 ;')
+
+    foorth_raises('TempClass .: .seesaw" 6 ;')
+
+    foorth_equal('String .: .seesaw" self 2 * ; ', [])
+    foorth_equal(' .seesaw"ab" ', ['abab'])
+
+  end
+
+  def test_methods_with_local_vars
+    foorth_equal('Object .: .lvt5 dup var: lv lv @ * ;' , [])
+    foorth_equal('10 Object .new .lvt5 ' , [100])
+
+    foorth_equal('Object .: .lvt6 val: lv lv 10  * ;' , [])
+    foorth_equal('10 Object .new .lvt6 ' , [100])
+
+  end
+
+  def test_exclusive_methods
+    foorth_equal('class: X1 ' , [])
+    foorth_equal('X1 .new var$: $a' , [])
+    foorth_equal('X1 .new var$: $b' , [])
+
+    foorth_equal('X1 .: .foobar "foo" ; ' , [])
+
+    foorth_equal('$a @ .foobar' , ['foo'])
+    foorth_equal('$b @ .foobar' , ['foo'])
+
+    foorth_equal('$b @ .:: .foobar "bar" ;' , [])
+
+    foorth_equal('$a @ .foobar' , ['foo'])
+    foorth_equal('$b @ .foobar' , ['bar'])
+  end
+
+  def test_the_super_method
+    foorth_equal('class: X2 ' , [])
+    foorth_equal('X2 .new var$: $c' , [])
+    foorth_equal('X2 .: .foo 1 ; ' , [])
+    foorth_equal('$c @ .foo' , [1])
+
+    foorth_equal('X2 .subclass: X3 ' , [])
+    foorth_equal('X3 .new var$:  $d' , [])
+    foorth_equal('X3 .: .foo if super else 2 then ; ' , [])
+
+    foorth_equal('true  $d @ .foo' , [1])
+    foorth_equal('false $d @ .foo' , [2])
+
+    foorth_equal('$c @ .foo' , [1])
+  end
+
+  def test_for_unbalanced_code
+    foorth_raises('true if   ')
+    foorth_raises('true if : blah  ')
+
+  end
+
+  def test_for_delayed_compile
+    foorth_run('true if : tfdc_foo "foo" ; then')
+    foorth_equal('tfdc_foo', ["foo"])
+
+    foorth_run('false if : tfdc_bar "bar" ; then')
+    foorth_raises('tfdc_bar')
+
+    foorth_run('true if !: tfdd_foo "foo" ; then')
+    foorth_equal('tfdd_foo', ["foo"])
+
+    foorth_run('false if !: tfdd_bar "bar" ; then')
+    foorth_raises('tfdd_bar')
+
+    foorth_run('true if Object .: .tfde_foo "foo" ; then')
+    foorth_equal('Object .new .tfde_foo', ["foo"])
+
+    foorth_run('false if Object .: .tfde_bar "bar" ; then')
+    foorth_raises('Object .new .tfde_bar')
+
+    foorth_run('Object .new val$: $tfdf_obj')
+    foorth_run('true if $tfdf_obj .:: .tfdf_foo "foo" ; then')
+    foorth_equal('$tfdf_obj .tfdf_foo', ["foo"])
+
+    foorth_run('false if $tfdf_obj .:: .tfdf_bar "bar" ; then')
+    foorth_raises('$tfdf_obj .tfdf_bar')
+  end
+
+  def test_for_FILE_method
+    foorth_equal('_FILE_', ['A string.'])
+
+    nm = File.absolute_path('integration/_FILE_test.foorth')
+    foorth_equal('"integration/_FILE_test.foorth" .load ', [nm, 7, nm])
+  end
+
+end