nendo 0.4.1 → 0.5.0

data/test/{util-test.nnd → nendo-util-test.nnd}

@@ -32,7 +32,7 @@
     var))
 
 (test* "disasm info"
-" file:   ./test/util-test.nnd 
+" file:   ./test/nendo-util-test.nnd 
  lineno: 30 
  source: 
 (define
@@ -69,7 +69,7 @@ trampCall(
                 ___lambda = lambda { |_var| 
                     begin
                         trampCall(_var)
-                      rescue => __e ; __e.set_backtrace( [\"./test/util-test.nnd:32\"] + __e.backtrace ) ; raise __e
+                      rescue => __e ; __e.set_backtrace( [\"./test/nendo-util-test.nnd:32\"] + __e.backtrace ) ; raise __e
                     end
                 } ; ___lambda.call(
                       trampCall( self.__PLMARK_METHOD(  '+',
@@ -77,12 +77,12 @@ trampCall(
                             if @global_lisp_binding.has_key?('__PLMARK') then
                               trampCall(@__PLMARK)
                             else raise NameError.new( \"Error: undefined variable __PLMARK\", \"__PLMARK\" ) end
-                            rescue => __e ; __e.set_backtrace( [\"./test/util-test.nnd:31\"] + __e.backtrace ) ; raise __e
+                            rescue => __e ; __e.set_backtrace( [\"./test/nendo-util-test.nnd:31\"] + __e.backtrace ) ; raise __e
                           end                        ,
                       [
                             begin
                                 trampCall(_arg1)
-                              rescue => __e ; __e.set_backtrace( [\"./test/util-test.nnd:31\"] + __e.backtrace ) ; raise __e
+                              rescue => __e ; __e.set_backtrace( [\"./test/nendo-util-test.nnd:31\"] + __e.backtrace ) ; raise __e
                             end                          ,
                           1
                       ]

data/test/nendo_spec.rb

@@ -142,7 +142,6 @@ describe Nendo, "Japanese characters in regex " do
   end
   it "should" do
     @matchData.should be_true
-    pending( "JRuby can't compute correctly" ) if defined? JRUBY_VERSION
     @matchData[0].should == "あいうえお"
     @matchData[1].should == "あ"
   end
@@ -182,6 +181,8 @@ describe Evaluator, "When use Evaluator's util methods" do
     @evaluator.toRubySymbol( '^' ).should  == '__NKMARK'
     @evaluator.toRubySymbol( "_" ).should  == "__"
     @evaluator.toRubySymbol( '~' ).should  == '__CHMARK'
+    @evaluator.toRubySymbol( '...' ).should  == '__DOTDOTDOT'
+    @evaluator.toRubySymbol( '<...>' ).should  == '__LTMARK_DOTDOTDOT_GTMARK'
     @evaluator.toRubySymbol( "a?" ).should == "_a_QUMARK"
     @evaluator.toRubySymbol( "a?" ).should == "_a_QUMARK"
     @evaluator.toRubySymbol( "a!" ).should == "_a_EXMARK"
@@ -200,6 +201,8 @@ describe Evaluator, "When use Evaluator's util methods" do
     @evaluator.toLispSymbol( "_a_b" ).should == "a_b"
     @evaluator.toLispSymbol( "_a_b_c" ).should == "a_b_c"
     @evaluator.toLispSymbol( "_A_B_C" ).should == "A_B_C"
+    @evaluator.toLispSymbol( "__DOTDOTDOT" ).should == "..."
+    @evaluator.toLispSymbol( "__LTMARK_DOTDOTDOT_GTMARK" ).should == "<...>"
     @evaluator.toRubyValue( "a" ).should == "a"
     @evaluator.toRubyValue( "b" ).should == "b"
     @evaluator.toRubyValue( "true" ).should == "true"
@@ -223,19 +226,19 @@ describe Nendo, "when call evalStr() with literals" do
     @nendo.evalStr( " 1.1 " ).should == "1.1"
     @nendo.evalStr( " 1.0 " ).should == "1.0"
     @nendo.evalStr( ' "a" ' ).should == '"a"'
-    @nendo.evalStr( ' "日本語" ' ).should == '"日本語"'
     @nendo.evalStr( ' "\n" ' ).should == "\"\n\""
     @nendo.evalStr( ' "\r" ' ).should == "\"\\r\""
     @nendo.evalStr( ' "\t" ' ).should == "\"\\t\""
     @nendo.evalStr( ' "a" ' ).should == '"a"'
     @nendo.evalStr( ' "a\"b" ' ).should == '"a\"b"'
-    @nendo.evalStr( ' "日\"本\"語" ' ).should == '"日\"本\"語"'
     @nendo.evalStr( " true " ).should == "#t"
     @nendo.evalStr( " false " ).should == "#f"
     @nendo.evalStr( " nil " ).should == "nil"
     @nendo.evalStr( " #t " ).should == "#t"
     @nendo.evalStr( " #f " ).should == "#f"
-
+    pending( "JRuby can't compute correctly" ) if defined? JRUBY_VERSION
+    @nendo.evalStr( ' "日本語" ' ).should == '"日本語"'
+    @nendo.evalStr( ' "日\"本\"語" ' ).should == '"日\"本\"語"'
   end
 end
 
@@ -297,8 +300,8 @@ describe Nendo, "when reference global-variables." do
   it "should" do
     @nendo.evalStr( " (pair? *load-path*) " ).should == "#t"
     @nendo.evalStr( " (string? (car *load-path*)) " ).should == "#t"
-    @nendo.evalStr( " (car      *load-path*)  " ).should == "\"./spec\""
-    @nendo.evalStr( " (car (cdr *load-path*)) " ).should == "\"./lib\""
+    @nendo.evalStr( " (to-arr   *load-path*)  " ).should include( "./spec")
+    @nendo.evalStr( " (to-arr   *load-path*)  " ).should include( "./lib")
     @nendo.evalStr( " (string? (*FILE*)) " ).should == "#t"
     @nendo.evalStr( " (number? (*LINE*)) " ).should == "#t"
     @nendo.evalStr( " *nendo-version* " ).should == '"' + Nendo::Core.version + '"'
@@ -516,6 +519,33 @@ describe Nendo, "when call evalStr() with `modulo' function" do
   end
 end
 
+describe Nendo, "when use quote and syntax-quote " do
+  before do
+    @nendo = Nendo::Core.new()
+  end
+  it "should" do
+    @nendo.evalStr( " '() " ).should                                                 == "()"
+    @nendo.evalStr( " '1 " ).should                                                  == "1"
+    @nendo.evalStr( " '\"str\" " ).should                                            == '"str"'
+    @nendo.evalStr( " '(1 . 2) " ).should                                            == "(1 . 2)"
+    @nendo.evalStr( " (quote ())" ).should                                           == "()"
+    @nendo.evalStr( " (quote 1)" ).should                                            == "1"
+    @nendo.evalStr( " (quote \"str\") " ).should                                     == '"str"'
+    @nendo.evalStr( " (quote (1 . 2)) " ).should                                     == "(1 . 2)"
+    @nendo.evalStr( " (syntax-quote ())" ).should                                    == "()"
+    @nendo.evalStr( " (syntax-quote 1)" ).should                                     == "1"
+    @nendo.evalStr( " (syntax-quote \"str\") " ).should                              == '"str"'
+    @nendo.evalStr( " (syntax-quote (1 . 2)) " ).should                              == "(1 . 2)"
+    @nendo.evalStr( " (quote quote) " ).should                                       == "'"
+    @nendo.evalStr( " 'quote " ).should                                              == "'"
+    @nendo.evalStr( " ''1 " ).should                                                 == "'1"
+    @nendo.evalStr( " (quote syntax-quote) " ).should                                == "syntax-quote"
+    @nendo.evalStr( " (syntax-quote '1) " ).should                                   == "'1"
+    @nendo.evalStr( " (syntax-quote (quote 1)) " ).should                            == "'1"
+    @nendo.evalStr( " (quote (syntax-quote 1)) " ).should                            == "(syntax-quote 1)"
+  end
+end
+
 describe Nendo, "when read various list expressions" do
   before do
     @nendo = Nendo::Core.new()
@@ -865,10 +895,51 @@ describe Nendo, "when call evalStr() with built-in special forms" do
     @nendo.evalStr( " (apply1 + (range 10 1))" ).should == "55"
     @nendo.evalStr( " (apply1 cons '(1 2))" ).should == "(1 . 2)"
     @nendo.evalStr( " (apply1 list '(1 2 3))" ).should == "(1 2 3)"
-    lambda { @nendo.evalStr( " (error \"My Runtime Error\") " ) }.should            raise_error( RuntimeError )
+    lambda { @nendo.evalStr( " (error \"My Runtime Error\") " ) }.should                     raise_error( RuntimeError, /My Runtime Error/ )
+    lambda { @nendo.evalStr( " (error \"My Runtime Error\" '(a b c)) " ) }.should            raise_error( RuntimeError, /My Runtime Error [(]a b c[)]/ )
   end
 end
 
+describe Nendo, "when call evalStr() with built-in special forms (renamed symbol)" do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.loadInitFile
+  end
+  it "should" do
+    @nendo.evalStr( " (/nendo/core/begin 1) " ).should     == "1"
+    @nendo.evalStr( " (/nendo/core/begin 1 2) " ).should   == "2"
+    @nendo.evalStr( " (/nendo/core/begin 1 2 3) " ).should == "3"
+    @nendo.evalStr( " (/nendo/core/set! x 2) (/nendo/core/set! y (/nendo/core/begin (/nendo/core/set! x (* x 2)) (/nendo/core/set! x (* x 2)) (/nendo/core/set! x (* x 2)) 100))  (+ x y)" ).should == "116"
+    @nendo.evalStr( " (/nendo/core/let ()                 100) " ).should                                == "100"
+    @nendo.evalStr( " (/nendo/core/let ((a 11))           a) " ).should                                  == "11"
+    @nendo.evalStr( " (/nendo/core/let ((a 11) (b 22))    (+ a b)) " ).should                            == "33"
+    @nendo.evalStr( " (/nendo/core/let ((a 22)) (let ((b 33))   (+ a b))) " ).should                     == "55"
+    @nendo.evalStr( " (/nendo/core/let ((a 22)(b 33)) (let ((c 44) (d 55))   (+ a b c d))) " ).should    == "154"
+    @nendo.evalStr( " (/nendo/core/let  ((a (let ((b 2))   (+ 100 b))))  a) " ).should                   == "102"
+    @nendo.evalStr( " (/nendo/core/letrec ()                 100) " ).should                             == "100"
+    @nendo.evalStr( " (/nendo/core/letrec ((a 11))           a) " ).should                               == "11"
+    @nendo.evalStr( " (/nendo/core/letrec ((a 11) (b 22))    (+ a b)) " ).should                         == "33"
+    @nendo.evalStr( " (/nendo/core/letrec ((a 22)) (let ((b 33))   (+ a b))) " ).should                  == "55"
+    @nendo.evalStr( " (/nendo/core/letrec ((a 22)(b 33)) (let ((c 44) (d 55))   (+ a b c d))) " ).should == "154"
+    @nendo.evalStr( " (/nendo/core/letrec  ((a (let ((b 2))   (+ 100 b))))  a) " ).should                == "102"
+    @nendo.evalStr( " (/nendo/core/letrec ( (func1 (/nendo/core/lambda (x) 13))             (func2 (/nendo/core/lambda (x) (* 2 (func1))))  )     (list (func2) (func1))) " ).should == "(26 13)"
+    @nendo.evalStr( " (/nendo/core/letrec ( (func2 (/nendo/core/lambda (x) (* 2 (func1))))  (func1 (/nendo/core/lambda (x) 7))              )     (list (func2) (func1))) " ).should == "(14 7)"
+    @nendo.evalStr( " (/nendo/core/if true   't 'f)" ).should     == "t"
+    @nendo.evalStr( " (/nendo/core/if true   '(1) '(2))" ).should == "(1)"
+    @nendo.evalStr( " (/nendo/core/if false  't 'f)" ).should     == "f"
+    @nendo.evalStr( " (/nendo/core/if false  '(1) '(2))" ).should == "(2)"
+    @nendo.evalStr( " (/nendo/core/set! x 0) (/nendo/core/if true  (set! x 1) (set! x 2))   x" ).should == "1"
+    @nendo.evalStr( " (/nendo/core/set! x 0) (/nendo/core/if false (set! x 1) (set! x 2))   x" ).should == "2"
+    @nendo.evalStr( " (/nendo/core/set! func (/nendo/core/lambda (arg1) arg1))              (list (func 1) (func 2))" ).should == "(1 2)"
+    @nendo.evalStr( " ((/nendo/core/lambda (arg1) arg1)  3)" ).should         == "3" 
+    @nendo.evalStr( " ((/nendo/core/lambda (arg1) arg1)  (+ 1 2 3))" ).should == "6" 
+    @nendo.evalStr( " ((/nendo/core/if #t + *) 3 4)" ).should                 == "7" 
+    @nendo.evalStr( " ((/nendo/core/if #f + *) 3 4)" ).should                 == "12" 
+    lambda { @nendo.evalStr( " (/nendo/core/error \"My Runtime Error\") " ) }.should            raise_error( RuntimeError )
+  end
+end
+
+
 describe Nendo, "when call evalStr() with global and lexical scope variable" do
   before do
     @nendo = Nendo::Core.new()
@@ -1176,9 +1247,15 @@ describe Nendo, "when call functions in init.nnd " do
     @nendo.evalStr( " (to-s      10) " ).should == '"10"'
     @nendo.evalStr( " (to_s      10) " ).should == '"10"'
     @nendo.evalStr( " (x->string 10) " ).should == '"10"'
+    @nendo.evalStr( " (number->string 11) " ).should == '"11"'
     @nendo.evalStr( " (to-s      2.1) " ).should == '"2.1"'
     @nendo.evalStr( " (to_s      2.1) " ).should == '"2.1"'
     @nendo.evalStr( " (x->string 2.1) " ).should == '"2.1"'
+    @nendo.evalStr( " (number->string 2.2) " ).should == '"2.2"'
+    @nendo.evalStr( ' (string-append) ' ).should == '""'
+    @nendo.evalStr( ' (string-append "a") ' ).should == '"a"'
+    @nendo.evalStr( ' (string-append "a" "b") ' ).should == '"ab"'
+    @nendo.evalStr( ' (string-append "a" "B" "c" "D" "e") ' ).should == '"aBcDe"'
     @nendo.evalStr( " (to_i    \"22\") " ).should == '22'
     @nendo.evalStr( " (to-i    \"22\") " ).should == '22'
     @nendo.evalStr( " (to_i    \"10000\") " ).should == '10000'
@@ -1187,6 +1264,23 @@ describe Nendo, "when call functions in init.nnd " do
     @nendo.evalStr( " (let1 aaa (+ 2 3) aaa) " ).should == "5"
     @nendo.evalStr( " (let1 aaa 333 (let1 bbb 444 (+ aaa bbb))) " ).should == "777"
     @nendo.evalStr( " (let1 aaa 333 (let1 bbb 444 (set! bbb 555) (+ aaa bbb))) " ).should == "888"
+    @nendo.evalStr( " (memq 'b '(a b c d)) " ).should ==                      "(b c d)"
+    @nendo.evalStr( " (memq 'c '(a b c d)) " ).should ==                      "(c d)"
+    @nendo.evalStr( " (memq 'd '(a b c d)) " ).should ==                      "(d)"
+    @nendo.evalStr( " (memq 'e '(a b c d)) " ).should ==                      "#f"
+    @nendo.evalStr( " (memq 'e '(a b c d . e)) " ).should ==                  "#f"
+    @nendo.evalStr( ' (memq "b" \'("a" "b" "c" "d")) ' ).should ==            '("b" "c" "d")'
+    @nendo.evalStr( ' (memv "b" \'("a" "b" "c" "d")) ' ).should ==            '("b" "c" "d")'
+    @nendo.evalStr( ' (memv "c" \'("a" "b" "c" "d")) ' ).should ==            '("c" "d")'
+    @nendo.evalStr( ' (memv "d" \'("a" "b" "c" "d")) ' ).should ==            '("d")'
+    @nendo.evalStr( ' (memv "e" \'("a" "b" "c" "d")) ' ).should ==           '#f'
+    @nendo.evalStr( ' (memv "e" \'("a" "b" "c" "d" . "e")) ' ).should ==     '#f'
+    @nendo.evalStr( ' (memv \'("b") \'(("a") ("b") ("c") ("d"))) ' ).should ==            '#f'
+    @nendo.evalStr( ' (member \'("b") \'(("a") ("b") ("c") ("d"))) ' ).should ==          '(("b") ("c") ("d"))'
+    @nendo.evalStr( ' (member \'("c") \'(("a") ("b") ("c") ("d"))) ' ).should ==          '(("c") ("d"))'
+    @nendo.evalStr( ' (member \'("d") \'(("a") ("b") ("c") ("d"))) ' ).should ==          '(("d"))'
+    @nendo.evalStr( ' (member \'("e") \'(("a") ("b") ("c") ("d"))) ' ).should ==          '#f'
+    @nendo.evalStr( ' (member \'("e") \'(("a") ("b") ("c") ("d") . ("e"))) ' ).should ==  '#f'
     @nendo.evalStr( " (let1 v (map (lambda (x) x) '(1 2 3))  v) " ).should == "(1 2 3)"
     @nendo.evalStr( " (let  ((v (map (lambda (x) x) '(1 2 3)))) v) " ).should == "(1 2 3)"
     @nendo.evalStr( " (cond (true  1) (false 2)) " ).should == "1"
@@ -1270,12 +1364,18 @@ describe Nendo, "when call functions in init.nnd " do
     @nendo.evalStr( " (find       (lambda (x) (= x 2))       '(1 2 3)) " ).should == "2"
     @nendo.evalStr( " (find       (lambda (x) (not (= x 2))) '(1 2 3)) " ).should == "1"
     @nendo.evalStr( " (find       (lambda (x) (if (= x 2) (* x 100) false))   '(1 2 3)) " ).should == "2"
+    @nendo.evalStr( " (eq? find any)" ).should      == "#f"
+    @nendo.evalStr( " (find  even?  '(1 2 3)) " ).should == "2"
     @nendo.evalStr( " (filter-map (lambda (x) x)             '()) " ).should      == "()"
     @nendo.evalStr( " (filter-map (lambda (x) (= x 100))     '(1 2 3)) " ).should == "()"
     @nendo.evalStr( " (filter-map (lambda (x) (= x 2))       '(1 2 3)) " ).should == "(#t)"
     @nendo.evalStr( " (filter-map (lambda (x) (not (= x 2))) '(1 2 3)) " ).should == "(#t #t)"
     @nendo.evalStr( " (filter-map (lambda (x) (if (= x 2) (* x 10) false)) '(1 2 3)) " ).should == "(20)"
     @nendo.evalStr( " (filter-map (lambda (x) (if (not (= x 2)) (* x 10) false)) '(1 2 3)) " ).should == "(10 30)"
+    @nendo.evalStr( " (any   even?  '(1 2 3)) " ).should == "#t"
+    @nendo.evalStr( " (any   even?  '(1 3)) " ).should == "#f"
+    @nendo.evalStr( " (any   odd?   '(1 3)) " ).should == "#t"
+    @nendo.evalStr( " (any   (lambda (x) x) '(1 2 3)) " ).should == "1"
     @nendo.evalStr( " " +
                     "(let1 result '()" +
                     "  (do" +
@@ -1692,30 +1792,18 @@ describe Nendo, "when use hash-table feature " do
     @nendo.evalStr( " (hash-table-num-entries h)" ).should == "1"
     @nendo.evalStr( " (hash-table-clear! h)" ).should == "{}"
     @nendo.evalStr( " (hash-table-num-entries h)" ).should == "0"
-    @nendo.evalStr( " (set! h (hash-table '(\"a\" \"AAA\")   '(\"b\" \"BBB\")   '(\"c\" \"CCC\" 100)))  (hash-table-keys   h)" ).should == "(\"a\" \"b\" \"c\")"
-    @nendo.evalStr( " (set! h (hash-table '(\"a\" \"AAA\")   '(\"b\" \"BBB\")   '(\"c\" \"CCC\" 100)))  (hash-table-values h)" ).should == "((\"AAA\") (\"BBB\") (\"CCC\" 100))"
-    @nendo.evalStr( " (set! h (hash-table '(\"a\" . \"AAA\") '(\"b\" . \"BBB\") '(\"c\" . \"CCC\")))  h" ).should == "{\"a\"=>\"AAA\", \"b\"=>\"BBB\", \"c\"=>\"CCC\"}"
+    @nendo.evalStr( " (set! h (hash-table eq? '(\"a\" \"AAA\")   '(\"b\" \"BBB\")   '(\"c\" \"CCC\" 100)))  (hash-table-keys   h)" ).should == "(\"a\" \"b\" \"c\")"
+    @nendo.evalStr( " (set! h (hash-table eq? '(\"a\" \"AAA\")   '(\"b\" \"BBB\")   '(\"c\" \"CCC\" 100)))  (hash-table-values h)" ).should == "((\"AAA\") (\"BBB\") (\"CCC\" 100))"
+    @nendo.evalStr( " (set! h (hash-table eq? '(\"a\" . \"AAA\") '(\"b\" . \"BBB\") '(\"c\" . \"CCC\")))  h" ).should == "{\"a\"=>\"AAA\", \"b\"=>\"BBB\", \"c\"=>\"CCC\"}"
     @nendo.evalStr( " (hash-table-keys       h)" ).should == '("a" "b" "c")'
     @nendo.evalStr( " (hash-table-values     h)" ).should == '("AAA" "BBB" "CCC")'
     @nendo.evalStr( " (hash-table-map        h (lambda (a b) (+ a b)))" ).should == '("aAAA" "bBBB" "cCCC")'
     @nendo.evalStr( " (hash-table-for-each   h (lambda (a b) (+ a b)))" ).should == '("aAAA" "bBBB" "cCCC")'
-    @nendo.evalStr( " (set! h (hash-table '(a   AAA) '(b   BBB)))  (hash-table->alist h)" ).should   == "((a AAA) (b BBB))"
-    @nendo.evalStr( " (set! h (hash-table '(a . AAA) '(b   BBB)))  (hash-table->alist h)" ).should   == "((a . AAA) (b BBB))"
-    @nendo.evalStr( " (set! h (hash-table '(a   AAA) '(b . BBB)))  (hash-table->alist h)" ).should   == "((a AAA) (b . BBB))"
-    @nendo.evalStr( " (set! h (hash-table '(a . AAA) '(b . BBB)))  (hash-table->alist h)" ).should   == "((a . AAA) (b . BBB))"
-    @nendo.evalStr( " (define alist (hash-table->alist h)) alist" ).should   == "((a . AAA) (b . BBB))"
-    @nendo.evalStr( " (define h2 (alist->hash-table alist)) h2" ).should   == "{:a=>:AAA, :b=>:BBB}"
     @nendo.evalStr( " (set! h (make-hash-table)) " ).should == "{}"
-    @nendo.evalStr( " (hash-table-push! h 'a :AAA_1)  (hash-table->alist h)" ).should == "((a :AAA_1))"
-    @nendo.evalStr( " (hash-table-push! h 'a :AAA_2)  (hash-table->alist h)" ).should == "((a :AAA_2 :AAA_1))"
-    @nendo.evalStr( " (hash-table-push! h 'b :BBB_1)  (hash-table->alist h)" ).should == "((a :AAA_2 :AAA_1) (b :BBB_1))"
-    @nendo.evalStr( " (hash-table-push! h 'b :BBB_2)  (hash-table->alist h)" ).should == "((a :AAA_2 :AAA_1) (b :BBB_2 :BBB_1))"
-    @nendo.evalStr( " (set! h (hash-table '(true . 1) '(false . 2) '(nil . 3)))  h" ).should   == "{true=>1, false=>2, nil=>3}"
-    @nendo.evalStr( "   (hash-table->alist h) " ).should                                       == "((#t . 1) (#f . 2) (nil . 3))"
-    @nendo.evalStr( "   (hash-table-keys   h) " ).should                                       == "(#t #f nil)"
-    @nendo.evalStr( " (set! h (hash-table '(1 . true) '(2 . false) '(3 . nil)))  h" ).should   == "{1=>true, 2=>false, 3=>nil}"
-    @nendo.evalStr( "   (hash-table->alist h) " ).should                                       == "((1 . #t) (2 . #f) (3 . nil))"
-    @nendo.evalStr( "   (hash-table-keys   h) " ).should                                       == "(1 2 3)"
+    @nendo.evalStr( " (set! h (hash-table eq? '(true . 1) '(false . 2) '(nil . 3)))  h" ).should   == "{true=>1, false=>2, nil=>3}"
+    @nendo.evalStr( "   (hash-table-keys   h) " ).should                                           == "(#t #f nil)"
+    @nendo.evalStr( " (set! h (hash-table eq? '(1 . true) '(2 . false) '(3 . nil)))  h" ).should   == "{1=>true, 2=>false, 3=>nil}"
+    @nendo.evalStr( "   (hash-table-keys   h) " ).should                                           == "(1 2 3)"
   end
 end
 
@@ -1774,6 +1862,13 @@ describe Nendo, "tail call optimization " do
     @nendo.evalStr( " (setup-tailcall-mark '(begin (print \"abc\") 1 2 3)) " ).should == "(begin (print \"abc\") 1 2 3)"
     @nendo.evalStr( " (setup-tailcall-mark '(begin 1 2 (print \"abc\") 3)) " ).should == "(begin 1 2 (print \"abc\") 3)"
     @nendo.evalStr( " (setup-tailcall-mark '(begin 1 2 3 (print \"abc\"))) " ).should == "(begin 1 2 3 (%tailcall (print \"abc\")))"
+    @nendo.evalStr( " (setup-tailcall-mark '(lambda  (x) x)) " ).should                     == "(lambda (x) x)"
+    @nendo.evalStr( " (setup-tailcall-mark '(macro   (x) x)) " ).should                     == "(macro (x) x)"
+    @nendo.evalStr( " (setup-tailcall-mark '(%syntax (x) x)) " ).should                     == "(%syntax (x) x)"
+    @nendo.evalStr( " (setup-tailcall-mark '(%syntax (a b c) (begin a b c))) " ).should     == "(%syntax (a b c) (begin a b c))"
+    @nendo.evalStr( " (setup-tailcall-mark '(lambda  (x) (%syntax (y) x))) " ).should       == "(lambda (x) (%syntax (y) x))"
+    @nendo.evalStr( " (setup-tailcall-mark '(lambda  (x) (syntax-quote x))) " ).should      == "(lambda (x) (syntax-quote x))"
+    @nendo.evalStr( " (setup-tailcall-mark '(lambda  (x) (quote x))) " ).should             == "(lambda (x) 'x)"
     @nendo.evalStr( "" +
                     "(setup-tailcall-mark"+
                     "  '(lambda '(x)"+
@@ -1836,7 +1931,7 @@ describe Nendo, "tail call optimization " do
 end
 
 
-describe Nendo, "optional argument parser " do
+describe Nendo, "When use optional argument parser " do
   before do
     @nendo = Nendo::Core.new()
     @nendo.loadInitFile
@@ -1851,65 +1946,25 @@ describe Nendo, "optional argument parser " do
   end
 end
 
-
-describe Nendo, "(load path) and *load-path*" do
-  before do
-    @nendo = Nendo::Core.new()
-    @nendo.loadInitFile
-  end
-  it "should" do
-    @nendo.evalStr( ' (when (load "nendo/test")                   #t) ' ).should ==  "#t"
-    @nendo.evalStr( ' (when (load "nendo/test.nnd")               #t) ' ).should ==  "#t"
-    @nendo.evalStr( ' (when (load "nendo/test.nnd")               #t) ' ).should ==  "#t"
-    @nendo.evalStr( ' (when (load "./lib/nendo/test.nnd")         #t) ' ).should ==  "#t"
-    @nendo.evalStr( ' (when (load "../nendo/lib/nendo/test.nnd")  #t) ' ).should ==  "#t"
-    @nendo.evalStr( ' (when (use nendo.test) #t)   ' ).should ==                     "#t"
-    @nendo.evalStr( ' (set! *load-path* (list "a" "b")) ' ).should ==                '("a" "b")'
-    @nendo.evalStr( ' (add-load-path "./lib") ' ).should ==                          '("./lib" "a" "b")'
-    @nendo.evalStr( ' (add-load-path "./bin" #t) ' ).should ==                       '("./lib" "a" "b" "./bin")'
-    @nendo.evalStr( ' (when (load "nendo/test")                   #t) ' ).should ==  "#t"
-    lambda{ @nendo.evalStr( " (when (load \"nendo/not-exist-file\") #t) " ) }.should   raise_error(RuntimeError)
-  end
-end
-
-
-describe Nendo, "nendo.test library " do
+describe Nendo, "When use :optional argument feature " do
   before do
     @nendo = Nendo::Core.new()
     @nendo.loadInitFile
   end
   it "should" do
-        @nendo.evalStr( ' (when (load "nendo/test")                   #t) ' ).should ==  "#t"
-    @nendo.evalStr( " (when (File.exist? *test-record-file*) (File.unlink *test-record-file*))  #t" ).should == "#t"
-    @nendo.evalStr( " (test-output-file (.open \"/dev/null\" \"w\"))  #t" ).should == "#t"
-    @nendo.evalStr( " (test-start   \"EMPTY\") " ).should ==                                              '"EMPTY"'
-    @nendo.evalStr( " (test-section \"EMPTY-SECTION\") " ).should ==                                      '"EMPTY-SECTION"'
-    @nendo.evalStr( " (test-end) " ).should ==                                                            '0'
-    @nendo.evalStr( " *test-counts* " ).should ==                                                         '#(0 0 0 0)'
-
-    @nendo.evalStr( " (test-start   \"SUCCESS\") " ).should ==                                            '"SUCCESS"'
-    @nendo.evalStr( " (test-section \"SUCCESS-SECTION\") " ).should ==                                    '"SUCCESS-SECTION"'
-    @nendo.evalStr( " (test  \"test 1\" 1 (lambda () 1))                  *test-counts*" ).should ==      '#(1 1 0 0)'
-    @nendo.evalStr( " (test* \"test 2\" 1 1 eq?)                          *test-counts*" ).should ==      '#(2 2 0 0)'
-    @nendo.evalStr( " (test* \"test 3\" (+ 2 2) (* 2 2) eqv?)             *test-counts*" ).should ==      '#(3 3 0 0)'
-    @nendo.evalStr( " (test* \"test 4\" \"abc\" (+ \"a\" \"b\" \"c\"))    *test-counts*" ).should ==      '#(4 4 0 0)'
-    @nendo.evalStr( " (test* \"test 5\" '(1 . 2)  (cons 1 2))             *test-counts*" ).should ==      '#(5 5 0 0)'
-    @nendo.evalStr( " (test-end) " ).should ==                                                            '0'
-    @nendo.evalStr( " *test-counts* " ).should ==                                                         '#(5 5 0 0)'
-
-    @nendo.evalStr( " (test-start   \"FAIL\") " ).should ==                                               '"FAIL"'
-    @nendo.evalStr( " (test-section \"FAIL-SECTION\") " ).should ==                                       '"FAIL-SECTION"'
-    @nendo.evalStr( " (test  \"test 6\" 1 (lambda () 2))                  *test-counts*" ).should ==      '#(6 5 1 0)'
-    @nendo.evalStr( " (test* \"test 7\" 1 2 eqv?)                         *test-counts*" ).should ==      '#(7 5 2 0)'
-    @nendo.evalStr( " (test* \"test 8\" '(1) '(1) eq?)                    *test-counts*" ).should ==      '#(8 5 3 0)'
-    @nendo.evalStr( " (test* \"test 9\" \"ABC\" (+ \"a\" \"b\" \"c\"))    *test-counts*" ).should ==      '#(9 5 4 0)'
-    @nendo.evalStr( " (test* \"test 10\" '(1 . 2)  (cons 10 20))          *test-counts*" ).should ==      '#(10 5 5 0)'
-    @nendo.evalStr( " (test-end) " ).should ==                                                            '5'
-    @nendo.evalStr( " *test-counts* " ).should ==                                                         '#(10 5 5 0)'
-
-    @nendo.evalStr( " (define data #f)   data" ).should ==                                                "#f"
-    @nendo.evalStr( " (with-open *test-record-file* (lambda (in) (set! data (in.readline.chomp))))  data " ).should == 
-      '"Total:    10 tests,     5 passed,     5 failed,     0 aborted."'
+    @nendo.evalStr( '(define (func arg1 arg2) (list arg1 arg2))    (func 1 2)' ).should ==                                    "(1 2)"
+    @nendo.evalStr( '(define (func arg1 arg2 :optional (arg3 #f))  (list arg1 arg2 arg3))  (func 1 2)' ).should ==            "(1 2 #f)"
+    @nendo.evalStr( '(define (func arg1 arg2 :optional (arg3 #t))  (list arg1 arg2 arg3))  (func 1 2)' ).should ==            "(1 2 #t)"
+    @nendo.evalStr( '(define (func arg1 arg2 :optional (arg3  3))  (list arg1 arg2 arg3))  (func 1 2)' ).should ==            "(1 2 3)"
+    @nendo.evalStr( '(define (func arg1 arg2 :optional (arg3 #f))  (list arg1 arg2 arg3))  (func 1 2 30)' ).should ==         "(1 2 30)"
+    @nendo.evalStr( '(define (func arg1 arg2 :optional (arg3 #t))  (list arg1 arg2 arg3))  (func 1 2 40)' ).should ==         "(1 2 40)"
+    @nendo.evalStr( '(define (func arg1 arg2 :optional (arg3  3))  (list arg1 arg2 arg3))  (func 1 2 50)' ).should ==         "(1 2 50)"
+    @nendo.evalStr( '(define (func arg1 arg2 :optional (arg3  3))  (list arg1 arg2 arg3))  (func 1 2 "String")' ).should ==   '(1 2 "String")'
+
+    @nendo.evalStr( '(define func (lambda (arg1 arg2) (list arg1 arg2)))   (func 1 2)' ).should ==                            '(1 2)'
+    lambda { @nendo.evalStr( '(define func (lambda (arg1 arg2 :optional (arg3 #f))  (list arg1 arg2 arg3)))  (func 1 2)' ) }.should   raise_error( RuntimeError, /handle keyword argument/ )
+    lambda { @nendo.evalStr( '(define func (lambda (arg1 arg2 :optional (arg3 #t))  (list arg1 arg2 arg3)))  (func 1 2)' ) }.should   raise_error( RuntimeError, /handle keyword argument/ )
+    lambda { @nendo.evalStr( '(define func (lambda (arg1 arg2 :optional (arg3  3))  (list arg1 arg2 arg3)))  (func 1 2)' ) }.should   raise_error( RuntimeError, /handle keyword argument/ )
   end
 end
 

data/test/srfi-1-test.nnd

@@ -22,9 +22,6 @@
   (for-each display xs)
   (newline))
 
-(define (fixme token)
-  (printf "FIXME!: %s test was pending.\n" token))
-  
 (define (fail token . more)
   (error (sprintf "Error: test failed: %s" token))
   #f)
@@ -533,6 +530,13 @@
 	   (every (lambda (x) (memq x cells)) (pair-fold cons '() r))))
     (fail 'delete!:1))
 
+(or (let* ((x     (list 1 48 2 5 37))
+	   (cells (pair-fold cons '() x))
+	   (r     (delete! 5 x >)))
+      (and (equal? r '(48 5 37))
+	   (every (lambda (x) (memq x cells)) (pair-fold cons '() r))))
+    (fail 'delete!:2))
+
 (or (equal? '((a . 3) (b . 7) (c . 1))
 	    (delete-duplicates '((a . 3) (b . 7) (a . 9) (c . 1))
 			       (lambda (x y) (eq? (car x) (car y)))))
@@ -545,7 +549,7 @@
            (r     (delete-duplicates! x)))
       (and (equal? '(a b c z) r)
            (every (lambda (x) (memq x cells)) (pair-fold cons '() r))))
-    (fixme 'delete-duplicates!:1))
+    (fail 'delete-duplicates!:1))
 
 (or (equal? '(3 . #t) (assoc 6 
                              '((4 . #t) (3 . #t) (5 . #t))

data/test/srfi-2-test.nnd

@@ -0,0 +1,63 @@
+;;-*- mode: nendo; syntax: scheme -*-;;
+;;
+;; srfi-2-test.nnd - test suite for srfi-2
+;;  
+;;   Copyright (c) 2000-2010  Shiro Kawai  <shiro@acm.org>
+;;   
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following conditions
+;;   are met:
+;;   
+;;   1. Redistributions of source code must retain the above copyright
+;;      notice, this list of conditions and the following disclaimer.
+;;  
+;;   2. Redistributions in binary form must reproduce the above copyright
+;;      notice, this list of conditions and the following disclaimer in the
+;;      documentation and/or other materials provided with the distribution.
+;;  
+;;   3. Neither the name of the authors nor the names of its contributors
+;;      may be used to endorse or promote products derived from this
+;;      software without specific prior written permission.
+;;  
+;;   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+;;   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+;;   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+;;   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+;;   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+;;   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+;;   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+;;   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+(use nendo.test)
+(test-start "srfi-2 (and-let*)")
+
+;;===================================================================
+;;-------------------------------------------------------------------
+(test-section "srfi-2")
+(use srfi-2)
+(test-module 'srfi-2)
+
+(define (srfi-2-look-up key alist)
+  (and-let* ((x (assq key alist))) (cdr x)))
+(test* "and-let*" 3
+       (srfi-2-look-up 'c '((a . 1) (b . 2) (c . 3))))
+(test* "and-let*" #f
+       (srfi-2-look-up 'd '((a . 1) (b . 2) (c . 3))))
+(test* "and-let*" 3
+       (let ((x 3))
+         (and-let* (((positive? x))
+                    (y x))
+           y)))
+(test* "and-let*" #f
+       (let ((x -3))
+         (and-let* (((positive? x))
+                    (y x))
+           y)))
+
+
+;;===================================================================
+(test-end)

data/test/srfi-26-test.nnd

@@ -0,0 +1,89 @@
+;;-*- mode: nendo; syntax: scheme -*-;;
+;;
+;; srfi-26-test.nnd - Test suite for srfi-26
+;;  
+;;   Copyright (c) 2000-2010  Shiro Kawai  <shiro@acm.org>
+;;   
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following conditions
+;;   are met:
+;;   
+;;   1. Redistributions of source code must retain the above copyright
+;;      notice, this list of conditions and the following disclaimer.
+;;  
+;;   2. Redistributions in binary form must reproduce the above copyright
+;;      notice, this list of conditions and the following disclaimer in the
+;;      documentation and/or other materials provided with the distribution.
+;;  
+;;   3. Neither the name of the authors nor the names of its contributors
+;;      may be used to endorse or promote products derived from this
+;;      software without specific prior written permission.
+;;  
+;;   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+;;   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+;;   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+;;   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+;;   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+;;   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+;;   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+;;   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+(use nendo.test)
+(test-start "srfi-26 (cut cute)")
+
+;;===================================================================
+;;-------------------------------------------------------------------
+(test-section "srfi-26")
+(use srfi-26)
+(test-module 'srfi-26)
+
+;; The test cases are taken from the SRFI-26 test program by Sebastian Egner.
+(test* "cut list" '() ((cut list)))
+(test* "cut list <...>" '() ((cut list <...>)))
+(test* "cut list 1" '(1) ((cut list 1)))
+(test* "cut list <>" '(1) ((cut list <>) 1))
+(test* "cut list <...>" '(1) ((cut list <...>) 1))
+(test* "cut list 1 2" '(1 2) ((cut list 1 2)))
+(test* "cut list 1 <>" '(1 2) ((cut list 1 <>) 2))
+(test* "cut list 1 <...>" '(1 2) ((cut list 1 <...>) 2))
+(test* "cut list 1 <...>" '(1 2 3 4) ((cut list 1 <...>) 2 3 4))
+(test* "cut list 1 <> 3 <>" '(1 2 3 4) ((cut list 1 <> 3 <>) 2 4))
+(test* "cut list 1 <> 3 <...>" '(1 2 3 4 5 6) ((cut list 1 <> 3 <...>) 2 4 5 6))
+;;
+;; FIXME!: these test was pending. (by Kiyoka Nishiyama)
+;; because it doesn't pass `cut' syntax from chibi-scheme-0.3 
+;;
+;;(test* "cut (eval order)" '(ok)
+;;       (let* ((x 'wrong) (y (cut list x))) (set! x 'ok) (y)))
+;;(test* "cut (eval order)" 2
+;;       (let ((a 0))
+;;         (map (cut + (begin (set! a (+ a 1)) a) <>)
+;;              '(1 2))
+;;         a))
+
+(test* "cute list" '() ((cute list)))
+(test* "cute list <...>" '() ((cute list <...>)))
+(test* "cute list 1" '(1) ((cute list 1)))
+(test* "cute list <>" '(1) ((cute list <>) 1))
+(test* "cute list <...>" '(1) ((cute list <...>) 1))
+(test* "cute list 1 2" '(1 2) ((cute list 1 2)))
+(test* "cute list 1 <>" '(1 2) ((cute list 1 <>) 2))
+(test* "cute list 1 <...>" '(1 2) ((cute list 1 <...>) 2))
+(test* "cute list 1 <...>" '(1 2 3 4) ((cute list 1 <...>) 2 3 4))
+(test* "cute list 1 <> 3 <>" '(1 2 3 4) ((cute list 1 <> 3 <>) 2 4))
+(test* "cute list 1 <> 3 <...>" '(1 2 3 4 5 6) ((cute list 1 <> 3 <...>) 2 4 5 6))
+(test* "cute (eval order)" '(ok)
+       (let* ((x 'ok) (y (cute list x))) (set! x 'wrong) (y)))
+(test* "cute (eval order)" 1
+       (let ((a 0))
+         (map (cute + (begin (set! a (+ a 1)) a) <>)
+              '(1 2))
+         a))
+
+
+;;===================================================================
+(test-end)