nendo 0.5.2 → 0.5.3

data/test/nendo-util-test.nnd

@@ -2,27 +2,8 @@
 ;; test for nendo's core utility
 
 (use nendo.test)
-(test-start "nendo's core utility")
-
-;;===================================================================
-(test-section "pretty-print-to-string")
-(define test-sexp1 '(a (b (c))))
-(define test-sexp2 '(define (function1 a b c) (+ a b c)))
-
-(test* "pretty-print-to-string"
-       (string-join
-        '("(a\n"
-          " (b\n"
-          "  (c)))\n"))
-       (pretty-print-to-string test-sexp1))
-
-(test* "pretty-print-to-string"
-       (string-join
-        '("(define\n"
-          " (function1 a b c)\n"
-          " (+ a b c))\n"))
-       (pretty-print-to-string test-sexp2))
 
+(test-start "nendo's core utility")
 
 ;;-------------------------------------------------------------------
 (test-section "disasm")
@@ -32,8 +13,8 @@
     var))
 
 (test* "disasm info"
-" file:   ./test/nendo-util-test.nnd 
- lineno: 30 
+       " file:   ./test/nendo-util-test.nnd 
+ lineno: 11 
  source: 
 (define
  (dummy-function arg1)
@@ -46,8 +27,7 @@
   (%let
    ((var
      (+ arg1 1))) var)))
-"
-       (disasm 'dummy-function 'info))
+"       (disasm 'dummy-function 'info))
 (test* "disasm source  "
        '(define (dummy-function arg1) (let1 var (+ arg1 1) var))
        (disasm 'dummy-function 'source))
@@ -67,16 +47,19 @@ trampCall(
                 ___lambda = lambda { |_var| 
                     begin
                         trampCall(_var)
-                      rescue => __e ; __e.set_backtrace( [\"./test/nendo-util-test.nnd:32\"] + __e.backtrace ) ; raise __e
+                      rescue => __e ; __e.set_backtrace( [\"./test/nendo-util-test.nnd:13\"] + __e.backtrace ) ; raise __e
                     end
                 } ; ___lambda.call(
-                      __PLMARK_ARGS2(
-                          begin
-                              trampCall(_arg1)
-                            rescue => __e ; __e.set_backtrace( [\"./test/nendo-util-test.nnd:31\"] + __e.backtrace ) ; raise __e
-                          end                        ,
-                        1
-                      )
+                      begin
+                        embedBacktraceInfo( \"./test/nendo-util-test.nnd\", 12 ); 
+                          __PLMARK_ARGS2(
+                              begin
+                                  trampCall(_arg1)
+                                rescue => __e ; __e.set_backtrace( [\"./test/nendo-util-test.nnd:12\"] + __e.backtrace ) ; raise __e
+                              end                            ,
+                            1
+                          )
+                      end
                            )
               end
           }
@@ -85,5 +68,308 @@ trampCall(
  )"
        (disasm 'dummy-function))
 
+
+;;===================================================================
+(test-section "pretty-print-to-string")
+(define test-sexp1 '(a (b (c))))
+(define test-sexp2 '(define (function1 a b c) (+ a b c)))
+
+(test* "pretty-print-to-string"
+       (string-join
+        '("(a\n"
+          " (b\n"
+          "  (c)))\n"))
+       (pretty-print-to-string test-sexp1))
+
+(test* "pretty-print-to-string"
+       (string-join
+        '("(define\n"
+          " (function1 a b c)\n"
+          " (+ a b c))\n"))
+       (pretty-print-to-string test-sexp2))
+
+
+(define (wrap-str str)
+  (+ "[" str "]"))
+
+
+;;-------------------------------------------------------------------
+(test-section "map for Enumerable")
+
+(test* "map-pable? no"
+       #f
+       (%%map-able?
+        (lambda (x) x)
+        ' (1 2)))
+
+(test* "map-pable? yes"
+       #t
+       (%%map-able?
+        (lambda (x) x)
+        '#(1 2)))
+
+(test* "map-pable? yes"
+       #t
+       (%%map-able?
+        (lambda (x) x)
+        (Range.new 0 100)))
+
+(test* "map-pable? yes"
+       #t
+       (%%map-able?
+        (lambda (x) x)
+        (hash-table eq? '("a" 1) '("b" 2))))
+
+(test* "%%map"
+       '#("[a]" "[b]" "[C]")
+       (%%map
+        wrap-str
+        '#("a" "b" "C")))
+
+(test* "%map (for vector)"
+       '#("[a]" "[b]" "[C]")
+       (%map
+        wrap-str
+        '#("a" "b" "C")))
+
+(test* "map (for vector)"
+       '#("[a]" "[b]" "[C]")
+       (map
+        wrap-str
+        '#("a" "b" "C")))
+
+(test* "map (for list)"
+       '("[a]" "[b]" "[C]")
+       (map
+        wrap-str
+        '("a" "b" "C")))
+
+(test* "map (for lists)"
+       '("[1:3:5]" "[2:4:6]")
+       (map
+        (lambda (x y z) (+ "[" x ":" y ":" z "]"))
+        '("1" "2")
+        '("3" "4")
+        '("5" "6")))
+
+;;-------------------------------------------------------------------
+(test-section "for-each for Enumerable")
+
+(test* "for-each-pable? no"
+       #f
+       (%%for-each-able?
+        (lambda (x) x)
+        ' (1 2)))
+
+(test* "for-each-pable? yes"
+       #t
+       (%%for-each-able?
+        (lambda (x) x)
+        '#(1 2)))
+
+(test* "for-each-pable? yes"
+       #t
+       (%%for-each-able?
+        (lambda (x) x)
+        (Range.new 0 100)))
+
+(test* "for-each-pable? yes"
+       #t
+       (%%for-each-able?
+        (lambda (x) x)
+        (hash-table eq? '("a" 1) '("b" 2))))
+
+(test* "%%for-each"
+       '("[a]" "[b]" "[C]")
+       (let1 result '()
+         (%%for-each
+          (lambda (x) (set! result
+                            (cons (wrap-str x) result)))
+          '#("a" "b" "C"))
+         (reverse result)))
+
+(test* "%for-each (for vector)"
+       '("[a]" "[b]" "[C]")
+       (let1 result '()
+         (%for-each
+          (lambda (x) (set! result
+                            (cons (wrap-str x) result)))
+          '#("a" "b" "C"))
+         (reverse result)))
+
+(test* "for-each (for vector)"
+       '("[a]" "[b]" "[C]")
+       (let1 result '()
+         (for-each
+          (lambda (x) (set! result
+                            (cons (wrap-str x) result)))
+          '#("a" "b" "C"))
+         (reverse result)))
+
+(test* "for-each (for list)"
+       '("[a]" "[b]" "[C]")
+       (let1 result '()
+         (for-each
+          (lambda (x) (set! result
+                            (cons (wrap-str x) result)))
+          '("a" "b" "C"))
+         (reverse result)))
+
+(test* "for-each (for lists)"
+       '("[1:3:5]" "[2:4:6]")
+       (let1 result '()
+         (for-each
+          (lambda (x y z)
+            (set! result
+                  (cons
+                   (+ "[" x ":" y ":" z "]")
+                   result)))
+          
+          '("1" "2")
+          '("3" "4")
+          '("5" "6"))
+         (reverse result)))
+
+
+;;-------------------------------------------------------------------
+(test-section "filter for Enumerable")
+
+(test* "filter-pable? no"
+       #f
+       (%%filter-able?
+        (lambda (x) x)
+        ' (1 2)))
+
+(test* "filter-pable? yes"
+       #t
+       (%%filter-able?
+        (lambda (x) x)
+        '#(1 2)))
+
+(test* "filter-pable? yes"
+       #t
+       (%%filter-able?
+        (lambda (x) x)
+        (Range.new 0 100)))
+
+(test* "filter-pable? yes"
+       #t
+       (%%filter-able?
+        (lambda (x) x)
+        (hash-table eq? '("a" 1) '("b" 2))))
+
+(test* "%%filter"
+       '#("b")
+       (%%filter
+        (lambda (x) (= "b" x))
+        '#("a" "b" "C")))
+
+(test* "%filter (for vector)"
+       '#("b")
+       (%filter
+        (lambda (x) (= "b" x))
+        '#("a" "b" "C")))
+
+(test* "filter (for vector1)"
+       '#("b")
+       (filter
+        (lambda (x) (= "b" x))
+        '#("a" "b" "C")))
+
+(test* "filter (for vector2)"
+       '#("a" "C")
+       (filter
+        (lambda (x) (not (= "b" x)))
+        '#("a" "b" "C")))
+
+(test* "filter (for list)"
+       '("C")
+       (filter
+        (lambda (x) (= "C" x))
+        '("a" "b" "C")))
+
+
+;;-------------------------------------------------------------------
+(test-section "Enumerable on srfi-1")
+(use srfi-1)
+
+(test* "map (for vector)"
+       '#("[a]" "[b]" "[C]")
+       (map
+        wrap-str
+        '#("a" "b" "C")))
+
+(test* "map (for Range)"
+       '#(10 11 12)
+       (map
+        (lambda (x) x)
+        (Range.new 10 12)))
+
+(test* "map (for Enumerator)"
+       '#("[one]" "[two]" "[three]")
+       (map
+        wrap-str
+        (Enumerator.new
+         (&block (v)
+           (v.yield "one")
+           (v.yield "two")
+           (v.yield "three")))))
+           
+
+(test* "for-each (for vector)"
+       '("[a]" "[b]" "[C]")
+       (let1 result '()
+         (for-each
+          (lambda (x) (set! result
+                            (cons (wrap-str x) result)))
+          '#("a" "b" "C"))
+         (reverse result)))
+
+(test* "for-each (for Range)"
+       '(10 11 12)
+       (let1 result '()
+         (for-each
+          (lambda (x) (set! result
+                            (cons x result)))
+          (Range.new 10 12))
+         (reverse result)))
+
+(test* "for-each (for Enumerable)"
+       '("[one]" "[two]" "[three]")
+       (let1 result '()
+         (for-each
+          (lambda (x) (set! result
+                            (cons (wrap-str x) result)))
+          (Enumerator.new
+           (&block (v)
+             (v.yield "one")
+             (v.yield "two")
+             (v.yield "three"))))
+         (reverse result)))
+
+(test* "filter (for vector)"
+       '#("b")
+       (filter
+        (lambda (x) (= "b" x))
+        '#("a" "b" "C")))
+
+(test* "filter (for Range)"
+       '#(11)
+       (filter
+        (lambda (x) (= 11 x))
+        (Range.new 10 1000)))
+
+(test* "filter (for Enumerable)"
+       '#("one" "three")
+       (filter
+        (lambda (x) (not (= "two" x)))
+        (Enumerator.new
+         (&block (v)
+           (v.yield "one")
+           (v.yield "two")
+           (v.yield "three")))))
+        
+
+
 ;;===================================================================
 (test-end)

data/test/nendo_spec.rb

@@ -335,6 +335,7 @@ end
 describe Nendo, "when call evalStr() with `+' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (+ 1) " ).should == "1"
@@ -361,6 +362,7 @@ end
 describe Nendo, "when call evalStr() with `-' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (- 1) " ).should == "-1"
@@ -383,6 +385,7 @@ end
 describe Nendo, "when call evalStr() with `*' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (* 1) " ).should == "1"
@@ -407,6 +410,7 @@ end
 describe Nendo, "when call evalStr() with `/' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (/ 1) " ).should == "1"
@@ -433,6 +437,7 @@ end
 describe Nendo, "when call evalStr() with `%' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (% 1) " ).should == "0"
@@ -455,6 +460,7 @@ end
 describe Nendo, "when call evalStr() with `quotient' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (quotient 2 1) " ).should == "2"
@@ -478,6 +484,7 @@ end
 describe Nendo, "when call evalStr() with `remainder' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (remainder 2 1) " ).should == "0"
@@ -501,6 +508,7 @@ end
 describe Nendo, "when call evalStr() with `modulo' function" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (modulo 2 1) " ).should == "0"
@@ -718,6 +726,7 @@ end
 describe Nendo, "when read various vector expressions" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " '() " ).should == "()"
@@ -743,6 +752,7 @@ end
 describe Nendo, "when call evalStr() with built-in functions" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (car '(1 2 3 4)) " ).should == "1"
@@ -936,6 +946,7 @@ end
 describe Nendo, "when call evalStr() with undefined variable" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     lambda { @nendo.evalStr( " true " ) }.should_not                   raise_error
@@ -952,6 +963,7 @@ end
 describe Nendo, "when call evalStr() with built-in special forms" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
   end
   it "should" do
     @nendo.evalStr( " (begin 1) " ).should == "1"
@@ -980,14 +992,14 @@ EOS
     @nendo.evalStr( " (letrec ((a 22)(b 33)) (%let ((c 44) (d 55))   (+ a b c d))) " ).should == "154"
     @nendo.evalStr( " (letrec  ((a (%let ((b 2))   (+ 100 b))))  a) " ).should == "102"
     @nendo.evalStr( <<EOS
-(letrec ((func1 (lambda (x) 13))
-         (func2 (lambda (x) (* 2 (func1)))))
+(letrec ((func1 (lambda () 13))
+         (func2 (lambda () (* 2 (func1)))))
   (list (func2) (func1)))
 EOS
            ).should == "(26 13)"
     @nendo.evalStr( <<EOS
-(letrec ((func2 (lambda (x) (* 2 (func1))))
-         (func1 (lambda (x) 7)))
+(letrec ((func2 (lambda () (* 2 (func1))))
+         (func1 (lambda () 7)))
   (list (func2) (func1)))
 EOS
     ).should == "(14 7)"
@@ -1015,12 +1027,15 @@ EOS
     @nendo.evalStr( " (apply1 list '(1 2 3))" ).should == "(1 2 3)"
     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[)]/ )
+    @nendo.evalStr( "((lambda (arg1) (+ 1 arg1)) 2)" ).should == "3"
+    lambda { @nendo.evalStr( "((lambda (arg1) (+ 1 arg1)))" ) }.should                       raise_error( ArgumentError, /wrong number of arguments/ )
   end
 end
 
 describe Nendo, "when call evalStr() with built-in special forms (renamed symbol)" do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -1050,14 +1065,14 @@ EOS
     @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( <<EOS
-(/nendo/core/letrec ((func1 (/nendo/core/lambda (x) 13))
-                     (func2 (/nendo/core/lambda (x) (* 2 (func1)))))
+(/nendo/core/letrec ((func1 (/nendo/core/lambda () 13))
+                     (func2 (/nendo/core/lambda () (* 2 (func1)))))
    (list (func2) (func1)))
 EOS
            ).should == "(26 13)"
     @nendo.evalStr( <<EOS
-(/nendo/core/letrec ((func2 (/nendo/core/lambda (x) (* 2 (func1))))
-                     (func1 (/nendo/core/lambda (x) 7)))
+(/nendo/core/letrec ((func2 (/nendo/core/lambda () (* 2 (func1))))
+                     (func1 (/nendo/core/lambda () 7)))
    (list (func2) (func1)))
 EOS
            ).should == "(14 7)"
@@ -1084,6 +1099,7 @@ end
 describe Nendo, "when redefined built-in functions(1)." do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -1199,6 +1215,7 @@ end
 describe Nendo, "when use #xxxx syntax " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -1278,6 +1295,7 @@ end
 describe Nendo, "when use regexp litteral and library functions " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -1792,6 +1810,7 @@ end
 describe Nendo, "when use values " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -1835,7 +1854,6 @@ EOS
 EOS
            ).should == "()"
     @nendo.evalStr( " (call-with-values * -) " ).should == "-1"
-    @nendo.evalStr( " (receive (a)       (values)           (list a))       " ).should == "()"
     @nendo.evalStr( " (receive (a)       (values 10)        (list a))       " ).should == "(10)"
     @nendo.evalStr( " (receive (a b)     (values 10 20)     (list a b))     " ).should == "(10 20)"
     @nendo.evalStr( " (receive (a b c)   (values 10 20 30)  (list a b c))   " ).should == "(10 20 30)"
@@ -1854,12 +1872,38 @@ EOS
     @nendo.evalStr( " (receive (a b)     (values nil #t)    (cons a b))     " ).should == "(nil . #t)"
     @nendo.evalStr( " (receive (a b)     (values nil #f)    (cons a b))     " ).should == "(nil . #f)"
     @nendo.evalStr( " (receive (a b)     (values nil nil)   (cons a b))     " ).should == "(nil . nil)"
+    lambda { @nendo.evalStr( " (receive (a)       (values)           (list a))       " ) }.should   raise_error( ArgumentError, /wrong number of arguments/ )
+    lambda { @nendo.evalStr( <<EOS
+(map
+ (lambda (a)   a))
+EOS
+                    ) }.should   raise_error( ArgumentError, /wrong number of arguments/ )
+    lambda { @nendo.evalStr( <<EOS
+(map
+ (lambda () 1)
+ '(1 2 3))
+EOS
+                    ) }.should   raise_error( ArgumentError, /wrong number of arguments/ )
+    lambda { @nendo.evalStr( <<EOS
+(map
+ (lambda (a)   a)
+ '(1 2 3)
+ '(10 20 30))
+EOS
+                    ) }.should   raise_error( ArgumentError, /wrong number of arguments/ )
+    lambda { @nendo.evalStr( <<EOS
+(map
+ (lambda (a b)   (+ a b))
+ '(1 2 3))
+EOS
+                    ) }.should   raise_error( ArgumentError, /wrong number of arguments/ )
   end
 end
 
 describe Nendo, "when toplevel variable was overwritten " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -1992,7 +2036,7 @@ EOS
 EOS
            ).should == "(define main (lambda (argv) (letrec ((result (quote ())) (foo (lambda (x) x)) (val 0) (bar (lambda (x) (+ val 10)))))))"
     @nendo.evalStr( <<EOS
-(define (main argv)
+(define (main . argv)
   (define (foo x) x)
   (+ 10 20)
   0
@@ -2073,6 +2117,7 @@ end
 describe Nendo, "when use dot-operator (.) macro " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -2092,8 +2137,7 @@ describe Nendo, "when use dot-operator (.) macro " do
     @nendo.evalStr( " (to-s str.size) " ).should == '"6"'
     @nendo.evalStr( " (to-s 'str.size) " ).should == '"str.size"'
     @nendo.evalStr( " (require \"date\") " ).should == "#f"
-    @nendo.evalStr( " (. (Date.new 0) strftime \"%x\") " ).should == '"01/01/00"'
-    @nendo.evalStr( " (. (Date.new 0) strftime \"%s\") " ).should == '"-62167392000"'
+    @nendo.evalStr( " (. (Date.new 0) strftime \"%F %r\") " ).should == '"0000-01-01 12:00:00 AM"'
     @nendo.evalStr( " (require \"digest/md5\") " ).should == "#f"
     @nendo.evalStr( " (Digest::MD5.hexdigest \"abc\") " ).should ==           '"900150983cd24fb0d6963f7d28e17f72"'
     @nendo.evalStr( " (Digest::MD5.hexdigest \"source text\") " ).should ==   '"20f79a1416626eeacc0bd9a8db87faa2"'
@@ -2147,6 +2191,7 @@ end
 describe Nendo, "when use with-open libraries " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
     @fn = "/tmp/for-with-open.dat"
     open( @fn, "w" ) { |f|
@@ -2159,6 +2204,7 @@ describe Nendo, "when use with-open libraries " do
     @nendo.evalStr( sprintf( " (with-open \"%s\" (lambda (f) (f.readline.chop))) ", @fn )).should                         == '"line1"'
     @nendo.evalStr( sprintf( " (with-open \"%s\" (lambda (f) (f.readline.chop))) ", @fn )).should                         == '"line1"'
     @nendo.evalStr( sprintf( " (with-open \"%s\" (lambda (f) (f.readline.chop) (f.readline.chop))) ", @fn )).should       == '"line2"'
+    @nendo.evalStr( sprintf( " (with-open \"%s\" (lambda (f) (map (lambda (line) (line.chop)) f))) ", @fn )).should       == '#("line1" "line2" "line3")'
     @nendo.evalStr( sprintf( " (with-open \"%s\" (lambda (f) (f.puts \"Wrote from Nendo.\")) \"w\")  #t", @fn )).should   == "#t"
     @nendo.evalStr( sprintf( " (with-open \"%s\" (lambda (f) (f.readline.chop))) ", @fn )).should                         == '"Wrote from Nendo."'
     lambda { @nendo.evalStr( sprintf( " (with-open \"%s\" (lambda (f) #t) 1 2 ", @fn )) }.should                          raise_error(RuntimeError)
@@ -2173,6 +2219,7 @@ end
 describe Nendo, "when use (use ...) macro " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -2194,6 +2241,7 @@ end
 describe Nendo, "when use keyword feature " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -2235,6 +2283,7 @@ end
 describe Nendo, "when use hash-table feature " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -2312,6 +2361,7 @@ end
 describe Nendo, "when use vector feature " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -2356,6 +2406,7 @@ end
 describe Nendo, "tail call optimization " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
     @nendo.loadInitFile  # to self optimizing.  The init.nnd file will be loaded twice, so `filter' can be optimized on second loading phase.
   end
@@ -2532,6 +2583,7 @@ end
 describe Nendo, "When use :optional argument feature " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do
@@ -2555,6 +2607,7 @@ end
 describe Nendo, "when use export-to-ruby macro " do
   before do
     @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
     @nendo.loadInitFile
   end
   it "should" do