nendo 0.5.3 → 0.5.4

data/test/nendo_spec.rb

@@ -1807,6 +1807,22 @@ EOS
   end
 end
 
+describe Nendo, "when use raise function " do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
+    @nendo.loadInitFile
+  end
+  it "should" do
+    lambda { @nendo.evalStr( ' (%raise TypeError      "typeError"     "nendo_spec.rb:1  typeError"    ) ' ) }.should  raise_error( TypeError )
+    lambda { @nendo.evalStr( ' (%raise ArgumentError  "argumentError" "nendo_spec.rb:1  argumentError") ' ) }.should  raise_error( ArgumentError )
+    lambda { @nendo.evalStr( ' (raise TypeError       "typeError"                                     ) ' ) }.should  raise_error( TypeError )
+    lambda { @nendo.evalStr( ' (raise ArgumentError   "argumentError"                                 ) ' ) }.should  raise_error( ArgumentError )
+    lambda { @nendo.evalStr( ' (raise TypeError                                                       ) ' ) }.should  raise_error( TypeError )
+    lambda { @nendo.evalStr( ' (raise ArgumentError                                                   ) ' ) }.should  raise_error( ArgumentError )
+  end
+end
+
 describe Nendo, "when use values " do
   before do
     @nendo = Nendo::Core.new()
@@ -2127,8 +2143,8 @@ describe Nendo, "when use dot-operator (.) macro " do
     lambda { @nendo.evalStr( " (macroexpand '(. open)) " ) }.should                   raise_error( ArgumentError )
     lambda { @nendo.evalStr( " (macroexpand '(. open \"aaa\")) " ) }.should           raise_error( TypeError )
     @nendo.evalStr( " (macroexpand '(. a size)) " ).should == "(a.size)"
-    @nendo.evalStr( " (macroexpand '(. (. a size) to_s)) " ).gsub( /[12]0[0-9][0-9][0-9]/, "X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s))"
-    @nendo.evalStr( " (macroexpand '(. (. (. a size) to_s) to_i)) " ).gsub( /[12]0[0-9][0-9][0-9]/, "X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s)))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_i))"
+    @nendo.evalStr( " (macroexpand '(. (. a size) to_s)) " ).gsub( /_[0-9][0-9][0-9][0-9][0-9]/, "_X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s))"
+    @nendo.evalStr( " (macroexpand '(. (. (. a size) to_s) to_i)) " ).gsub( /_[0-9][0-9][0-9][0-9][0-9]/, "_X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s)))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_i))"
     lambda { @nendo.evalStr( " (macroexpand '(. (. a size))) " ) }.should             raise_error( ArgumentError )
     @nendo.evalStr( " (set! str \"str\") str.size " ).should == "3"
     @nendo.evalStr( " (set! str \"str\") (. str size) " ).should == "3"
@@ -2484,7 +2500,7 @@ EOS
                           (bar 2))
                         ))
 EOS
-           ).gsub( /[24]0[0-9][0-9][0-9]/, "X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (foo 1))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (bar 2))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 #f))))"
+           ).gsub( /_[0-9][0-9][0-9][0-9][0-9][ ]/, "_X0000 " ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (foo 1))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (bar 2))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 #f))))"
     @nendo.evalStr( <<EOS
 (%setup-%tailcall-mark (macroexpand
                         '(let loop ((x 1))

data/test/syntax_spec.rb

@@ -532,7 +532,7 @@ EOS
 (let ((x 'outer))
   (let-syntax ((m (syntax-rules () ((m) x))))
     (let ((x 'inner))
-      (m))))
+      (m)))) ;; '
 EOS
            ).should == "outer"
 
@@ -560,20 +560,20 @@ EOS
 EOS
            ).should == "outer"
 
-    pending( "nested let fails on limitation of Nendo's let-syntax." )
-
-    @nendo.evalStr( <<EOS
-(define z 'top-level-1)
-(let ((x 'outer1))
-  (let ((y x))
-    (let ((z y))
-      (let-syntax ((m (syntax-rules () ((m) z))))
-        (let ((x 'inner1))
-          (let ((y x))
-            (let ((z y))
-              (m))))))))
-EOS
-           ).should == "outer1"
+#    pending( "nested let fails on limitation of Nendo's let-syntax." )
+#
+#    @nendo.evalStr( <<EOS
+#(define z 'top-level-1)
+#(let ((x 'outer1))
+#  (let ((y x))
+#    (let ((z y))
+#      (let-syntax ((m (syntax-rules () ((m) z))))
+#        (let ((x 'inner1))
+#          (let ((y x))
+#            (let ((z y))
+#              (m))))))))
+#EOS
+#           ).should == "outer1"
 
   end
 end
@@ -709,3 +709,327 @@ EOS
 end
 
 
+describe Nendo, "When expand guard special form" do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.loadInitFile
+  end
+  it "should" do
+    @nendo.evalStr( <<EOS
+(macroexpand-1
+ (quote
+  (%guard-var (exc
+               (else (print "ELSE"))))))
+EOS
+                    ).should == "exc"
+
+    @nendo.evalStr( <<EOS
+(macroexpand-1
+ (quote
+  (%guard-var (exc
+               ((exc.is_a? RuntimeError)
+                (print "<<RuntimeError>>"))
+               (else (print "ELSE"))))))
+EOS
+                    ).should == "exc"
+
+    @nendo.evalStr( <<EOS
+(macroexpand-1
+ (quote
+  (%guard-var (exc
+               ((exc.is_a? RuntimeError)
+                (print "<<RuntimeError>>"))
+               (else
+                => (lambda (e)
+                     (printf "Type is [%s]\n" e.class)))))))
+EOS
+                    ).should == "exc"
+
+    @nendo.evalStr( <<EOS
+(macroexpand-1
+ (quote
+  (%guard-clause (exc
+                  (else (print "ELSE"))))))
+EOS
+                    ).should == '(cond (else (print "ELSE")))'
+
+
+    @nendo.evalStr( <<EOS
+(macroexpand-1
+ (quote
+  (%guard-clause (exc
+                  ((exc.is_a? RuntimeError)
+                   (print "<<RuntimeError>>"))
+                  (else (print "ELSE"))))))
+EOS
+                    ).should == '(cond ((exc.is_a? RuntimeError) (print "<<RuntimeError>>")) (else (print "ELSE")))'
+
+    @nendo.evalStr( <<EOS
+(macroexpand-1
+ (quote
+  (%guard-clause (exc
+                  ((exc.is_a? RuntimeError)
+                   (print "<<RuntimeError>>"))
+                  (else
+                   => (lambda (e)
+                        (printf "Type is [%s]\n" e.class)))))))
+EOS
+                    ).should == "(cond ((exc.is_a? RuntimeError) (print \"<<RuntimeError>>\")) (else feedto (lambda (e) (printf \"Type is [%s]\n\" e.class))))"
+
+  end
+end
+
+
+describe Nendo, "When use guard special form" do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.loadInitFile
+  end
+  it "should" do
+    @nendo.evalStr( <<EOS
+(guard
+ (exc (else (sprintf "Type is [%s]" (exc.class))))
+ (error "This is RuntimeError"))
+EOS
+                    ).should  == '"Type is [RuntimeError]"'
+
+    @nendo.evalStr( <<EOS
+(guard
+ (exc (else (sprintf "Type is [%s]" exc.class)))
+ (+ (Array.new) 1))
+EOS
+                    ).should  == '"Type is [TypeError]"'
+
+    @nendo.evalStr( <<EOS
+(guard
+ (exc (else (sprintf "Type is [%s]" exc.class)))
+ (+ (Array.new) 1)
+ (error "This is RuntimeError"))
+EOS
+                    ).should  == '"Type is [TypeError]"'
+
+    @nendo.evalStr( <<EOS
+(guard
+ (exc (else (sprintf "Type is [%s]" exc.class)))
+ (error "This is RuntimeError")
+ (+ (Array.new) 1))
+EOS
+                    ).should  == '"Type is [RuntimeError]"'
+
+    @nendo.evalStr( <<EOS
+(guard
+    (exc ((exc.is_a? RuntimeError)
+          "Type is [RuntimeError]")
+         ((exc.is_a? TypeError)
+          "Type is [TypeError]")
+         (else
+          "Type is Others"))
+  (error "This is RuntimeError")
+  (+ (Array.new) 1))
+EOS
+                    ).should  == '"Type is [RuntimeError]"'
+
+    @nendo.evalStr( <<EOS
+(guard
+    (exc ((exc.is_a? RuntimeError)
+          "Type is [RuntimeError]")
+         ((exc.is_a? TypeError)
+          "Type is [TypeError]"))
+  (+ (Array.new) 1)
+  (error "This is RuntimeError"))
+EOS
+                    ).should  == '"Type is [TypeError]"'
+
+    @nendo.evalStr( <<EOS
+(guard
+ (exc ((exc.is_a? TypeError)
+       "Type is [TypeError]"))
+ (+ (Array.new) 1)
+ (error "This is RuntimeError"))
+EOS
+                    ).should  == '"Type is [TypeError]"'
+
+    @nendo.evalStr( <<EOS
+(guard
+ (exc ((exc.is_a? RuntimeError)
+       "Type is [RuntimeError]"))
+ (error "This is RuntimeError")
+ (+ (Array.new) 1))
+EOS
+                    ).should  == '"Type is [RuntimeError]"'
+
+    @nendo.evalStr( <<EOS
+(begin
+  (guard
+      (exc ((exc.is_a? RuntimeError)
+            "Type is [RuntimeError]"))
+    (+ (Array.new) 1))
+  \"-END-\")
+EOS
+                    ).should  == '"-END-"'
+
+  end
+end
+
+
+
+describe Nendo, "When use guard and raise" do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
+    @nendo.loadInitFile
+  end
+  it "should" do
+    @nendo.evalStr( <<EOS
+(guard
+ (exc ((exc.is_a? TypeError)
+       "[TypeError]")
+      (else
+       "[OtherError]"))
+ (guard
+   (exc (else (+ "a" 1.1)))
+   (error "This is RuntimeError")))
+EOS
+           ).should  == '"[TypeError]"'
+
+    @nendo.evalStr( <<EOS
+(let1 lst '()
+   (guard
+       (exc (else (push! lst 2)))
+     (guard
+         (exc (else (push! lst 1)))
+       (error "Error occur")))
+   lst)
+EOS
+           ).should  == '(1)'
+
+    @nendo.evalStr( <<EOS
+(let1 lst '()
+  (guard
+      (exc (else (push! lst 2)))
+    (guard
+        (exc (else (push! lst 1)
+                   (error "Error occur(2)")))
+      (error "Error occur(1)")))
+  lst)
+EOS
+           ).should  == '(2 1)'
+
+
+    lambda { @nendo.evalStr( <<EOS
+(let1 lst '()
+  (guard
+      (exc (else (push! lst 3)
+                 (errorf "Error occur:%s" (write-to-string lst))))
+    (guard
+        (exc (else (push! lst 2)
+                   (error "Error occur(3)")))
+      (guard
+          (exc (else (push! lst 1)
+                     (error "Error occur(2)")))
+        (error "Error occur(1)"))))
+  #t)
+EOS
+                    ) }.should  raise_error( RuntimeError, /Error occur:[(]3 2 1[)]/ )
+
+
+    @nendo.evalStr( <<EOS
+(define a
+ (guard
+     (exc (else (exc.message))) ;; line 1
+   (raise RuntimeError)))
+(define b
+ (guard
+     (exc (else (exc.message))) ;; line 5
+   (raise NoMethodError)))
+(define c
+ (guard
+     (exc (else (exc.message))) ;; line 9
+   (raise ArgumentError)))
+(list a b c)
+EOS
+                    ).should  == '("(string):1 raised RuntimeError" "(string):5 raised NoMethodError" "(string):9 raised ArgumentError")'
+
+
+  end
+end
+
+
+describe Nendo, "When use unwind-protect" do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.setDisplayErrors( false )
+    @nendo.loadInitFile
+  end
+
+  it "should" do
+    @nendo.evalStr( "(macroexpand '(unwind-protect 1 2)) ;; '" ).should  match( /[(]%guard #<SyntacticClosure.exc:_exc__gensym/ )
+
+    lambda { @nendo.evalStr( <<EOS
+(let1 cnt 0
+  (begin
+    (set! cnt (+ cnt 1))
+    (set! cnt (+ cnt "string"))
+  ))
+EOS
+                    ) }.should  raise_error( TypeError )
+
+    @nendo.evalStr( <<EOS
+(let1 cnt 0
+  (unwind-protect
+      1
+    2))
+EOS
+           ).should  ==  '1'
+
+    @nendo.evalStr( <<EOS
+(let1 cnt 0
+  (unwind-protect
+      (begin 1 2)
+    3))
+EOS
+           ).should  ==  '2'
+
+    @nendo.evalStr( <<EOS
+(let* ([cnt 0]
+       [result (unwind-protect
+                   (begin
+                     (set! cnt (+ cnt 1))
+                     (set! cnt (+ cnt 2))
+                     (+ 1.1 "str")
+                     (set! cnt (+ cnt 3)))
+                 (set! cnt (+ cnt 100)))])
+  (list result cnt))
+EOS
+           ).should  ==  '(#f 103)'
+
+    @nendo.evalStr( <<EOS
+(let* ([cnt 0]
+       [result (unwind-protect
+                   (begin
+                     (set! cnt (+ cnt 10))
+                     (set! cnt (+ cnt 01))
+                     (error "[RuntimeError]")
+                     (set! cnt (+ cnt 02)))
+                 (set! cnt (+ cnt 100)))])
+  (list result cnt))
+EOS
+           ).should  ==  '(#f 111)'
+
+    @nendo.evalStr( <<EOS
+(let* ([cnt 0]
+       [result (unwind-protect
+                   (begin
+                     (set! cnt (+ cnt 10))
+                     (set! cnt (+ cnt 01))
+                     (guard (exc (else (set! cnt (+ cnt 100))))
+                       (error "[RuntimeError]"))
+                     (set! cnt (+ cnt 02)))
+                 (set! cnt (+ cnt 1000)))])
+  (list result cnt))
+EOS
+           ).should  ==  '(113 1113)'
+
+  end
+end
+

data/test/testframework_spec.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+#
+# syntax_spec.rb -  "RSpec file for nendo language (nendo.test framework part)"
+#
+#   Copyright (c) 2009-2011  Kiyoka Nishiyama  <kiyoka@sumibi.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.
+#
+require 'nendo'
+include Nendo
+require 'timeout'
+
+describe Nendo, "when use NendoTestError " do
+  before do
+    @nendoError1   = NendoTestError.new
+    @runtimeError  = RuntimeError.new
+    @argumentError = ArgumentError.new
+    @nendoError2   = NendoTestError.new( @runtimeError.class )
+  end
+
+  it "should" do
+    @nendoError1.type.should ==           RuntimeError
+    @nendoError1.type = @runtimeError.class
+    @nendoError1.type.should ==           RuntimeError
+    @nendoError1.type = RuntimeError
+    @nendoError1.type.should ==           RuntimeError
+    @nendoError1.type = Timeout::Error
+    @nendoError1.type.should ==           Timeout::Error
+    @nendoError2.type.should ==           RuntimeError
+  end
+end
+
+
+describe Nendo, "when use test function " do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.loadInitFile
+    @nendo.evalStr( "(use nendo.test)" )
+  end
+
+  it "should" do
+    @nendo.evalStr( '(test-section "(test)")' ).should  ==  '"(test)"'
+
+    @nendo.evalStr( '(test "true false" #t (lambda () #t))' ).should             ==  '#t'
+    @nendo.evalStr( '(test "true false" #f (lambda () #f))' ).should             ==  '#t'
+    @nendo.evalStr( '(test "number" 0 (lambda () 0))' ).should                   ==  '#t'
+    @nendo.evalStr( '(test "number" 0 (lambda () 1))' ).should                   ==  '#f'
+    @nendo.evalStr( '(test "string" "ab" (lambda () (+ "a" "b")))' ).should      ==  '#t'
+  end
+end
+
+describe Nendo, "when use test* function " do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.loadInitFile
+    @nendo.evalStr( "(use nendo.test)" )
+  end
+
+  it "should" do
+    @nendo.evalStr( '(test-section "(test*)")' ).should  ==  '"(test*)"'
+
+    @nendo.evalStr( '(test* "true false" #t #t)' ).should                        ==  '#t'
+    @nendo.evalStr( '(test* "true false" #f #f)' ).should                        ==  '#t'
+    @nendo.evalStr( '(test* "number" 0 0)' ).should                              ==  '#t'
+    @nendo.evalStr( '(test* "number" 0 1)' ).should                              ==  '#f'
+    @nendo.evalStr( '(test* "string" "ab" (+ "a" "b"))' ).should                 ==  '#t'
+    @nendo.evalStr( <<EOS
+(test* "eq?"     '(a b) '(a b)  eq?)
+EOS
+           ).should               ==  '#f'
+
+    @nendo.evalStr( <<EOS
+(test* "eqv?"     '(a b) '(a b) eqv?)
+EOS
+           ).should               ==  '#f'
+
+    @nendo.evalStr( <<EOS
+(test* "equal?"   '(a b) '(a b)     )
+EOS
+           ).should               ==  '#t'
+
+  end
+end
+
+
+describe Nendo, "when test framework handle exception " do
+  before do
+    @nendo = Nendo::Core.new()
+    @nendo.loadInitFile
+    @nendo.evalStr( "(use nendo.test)" )
+  end
+
+  it "should" do
+    @nendo.evalStr( '(test-section "exceptions")' ).should  ==  '"exceptions"'
+
+    @nendo.evalStr( '(. (test-error ) class)' ).should                     ==  'Nendo::NendoTestError'
+    @nendo.evalStr( '(. (test-error RuntimeError)  class)' ).should        ==  'Nendo::NendoTestError'
+
+    @nendo.evalStr( '(. (test-error RuntimeError)  type)' ).should         ==  'RuntimeError'
+    @nendo.evalStr( '(. (test-error ArgumentError) type)' ).should         ==  'ArgumentError'
+    @nendo.evalStr( '(. (test-error SyntaxError)   type)' ).should         ==  'SyntaxError'
+
+    @nendo.evalStr( '(test-error? (test-error))               ' ).should   ==  '#t'
+    @nendo.evalStr( '(test-error? (test-error RuntimeError))  ' ).should   ==  '#t'
+    @nendo.evalStr( '(test-error? (test-error ArgumentError)) ' ).should   ==  '#t'
+    @nendo.evalStr( '(test-error? (test-error SyntaxError))   ' ).should   ==  '#t'
+
+    @nendo.evalStr( '(test-check   (test-error RuntimeError)   (test-error RuntimeError ))' ).should   ==  '#t'
+    @nendo.evalStr( '(test-check   1                           (test-error RuntimeError ))' ).should   ==  '#f'
+    @nendo.evalStr( '(test-check   (test-error RuntimeError)   1                         )' ).should   ==  '#f'
+    @nendo.evalStr( '(test-check   1                           1                         )' ).should   ==  '#t'
+    @nendo.evalStr( '(test-check   1                           2                         )' ).should   ==  '#f'
+    @nendo.evalStr( '(test-check   (test-error RuntimeError)   (test-error ArgumentError))' ).should   ==  '#f'
+    @nendo.evalStr( '(test-check   (test-error RuntimeError)   (test-error SyntaxError  ))' ).should   ==  '#f'
+    @nendo.evalStr( '(test-check   (test-error ArgumentError)  (test-error RuntimeError ))' ).should   ==  '#f'
+    @nendo.evalStr( '(test-check   (test-error SyntaxError)    (test-error RuntimeError ))' ).should   ==  '#f'
+
+    @nendo.evalStr( '(test* "exception" (test-error TypeError)    (+ 1.1 "str"))' ).should                      ==  '#t'
+    @nendo.evalStr( '(test* "exception" (test-error RuntimeError) (+ 1.1 "str"))' ).should                      ==  '#f'
+    @nendo.evalStr( '(test* "exception" (test-error TypeError)    (error "[RuntimeError]"))' ).should           ==  '#f'
+    @nendo.evalStr( '(test* "exception" (test-error RuntimeError) (error "[RuntimeError]"))' ).should           ==  '#t'
+    @nendo.evalStr( '(test* "exception" (test-error ArgumentError)    (raise RuntimeError  "[RuntimeError]"))'  ).should           ==  '#f'
+    @nendo.evalStr( '(test* "exception" (test-error ArgumentError)    (raise ArgumentError "[ArgumentError]"))' ).should           ==  '#t'
+    @nendo.evalStr( '(test* "exception" (test-error ArgumentError)    (raise TypeError     "[TypeError]"))'     ).should           ==  '#f'
+    @nendo.evalStr( '(test* "exception" (test-error ArgumentError)    (raise NoMethodError "[NoMethodError]"))' ).should           ==  '#f'
+  end
+end

data/test/util-list-test.nnd

@@ -48,8 +48,8 @@
        (receive r (split-at* '(a b c d) 0) r))
 (test* "split-at* (boundary)" '((a b c d) ())
        (receive r (split-at* '(a b c d) 4) r))
-;;(test* "split-at* (error)" (test-error)
-;;       (receive r (split-at* '(a b c d) -1) r))
+(test* "split-at* (error)" (test-error)
+       (receive r (split-at* '(a b c d) -1) r))
 (test* "split-at* (shorten)" '((a b c d) ())
        (receive r (split-at* '(a b c d) 5) r))
 (test* "split-at* (fill)" '((a b c d #f #f) ())
@@ -60,7 +60,7 @@
 (test* "take* (normal)" '(a b c)      (take* '(a b c d) 3))
 (test* "take* (boundary)" '()         (take* '(a b c d) 0))
 (test* "take* (boundary)" '(a b c d)  (take* '(a b c d) 4))
-;;(test* "take* (error)" (test-error)   (take* '(a b c d) -1))
+(test* "take* (error)" (test-error)   (take* '(a b c d) -1))
 (test* "take* (shorten)" '(a b c d)   (take* '(a b c d) 5))
 (test* "take* (fill)" '(a b c d #f #f) (take* '(a b c d) 6 #t))
 (test* "take* (fill)" '(a b c d z z)  (take* '(a b c d) 6 #t 'z))
@@ -68,20 +68,20 @@
 (test* "drop* (normal)" '(c d)       (drop* '(a b c d) 2))
 (test* "drop* (boundary)" '(a b c d) (drop* '(a b c d) 0))
 (test* "drop* (boundary)" '()        (drop* '(a b c d) 4))
-;;(test* "drop* (error)" (test-error)  (drop* '(a b c d) -3))
+(test* "drop* (error)" (test-error)  (drop* '(a b c d) -3))
 (test* "drop* (past)" '()            (drop* '(a b c d) 5))
 
 (test* "take-right* (normal)" '(b c d)  (take-right* '(a b c d) 3))
 (test* "take-right* (boundary)" '()     (take-right* '(a b c d) 0))
 (test* "take-right* (boundary)" '(a b c d) (take-right* '(a b c d) 4))
-;;(test* "take-right* (error)" (test-error)  (take-right* '(a b c d) -1))
+(test* "take-right* (error)" (test-error)  (take-right* '(a b c d) -1))
 (test* "take-right* (shorten)" '(a b c d)  (take-right* '(a b c d) 6))
 (test* "take-right* (fill)" '(z z a b c d) (take-right* '(a b c d) 6 #t 'z))
 
 (test* "drop-right* (normal)" '(a b c)  (drop-right* '(a b c d) 1))
 (test* "drop-right* (boundary)" '()     (drop-right* '(a b c d) 4))
 (test* "drop-right* (boundary)" '(a b c d) (drop-right* '(a b c d) 0))
-;;(test* "drop-right* (error)" (test-error)  (drop-right* '(a b c d) -1))
+(test* "drop-right* (error)" (test-error)  (drop-right* '(a b c d) -1))
 (test* "drop-right* (past)" '()         (drop-right* '(a b c d) 7))
 
 (test* "slices (normal)" '((0 1 2 3) (4 5 6 7) (8 9 10 11) (12 13 14 15))

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: nendo
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 3
   prerelease: 
   segments: 
   - 0
   - 5
-  - 3
-  version: 0.5.3
+  - 4
+  version: 0.5.4
 platform: ruby
 authors: 
 - Kiyoka Nishiyama
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-13 00:00:00 Z
+date: 2011-10-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -168,6 +168,7 @@ files:
 - test/srfi-2-test.nnd
 - test/srfi-26-test.nnd
 - test/syntax_spec.rb
+- test/testframework_spec.rb
 - test/textlib-test.nnd
 - test/util-combinations-test.nnd
 - test/util-list-test.nnd
@@ -201,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Nendo is a dialect of Lisp.