Author: koutou
Date: Fri Dec 12 06:15:53 2008
New Revision: 5662
Added:
trunk/test/uim-assertions.scm
trunk/test/uim-test.scm
Modified:
trunk/test/util/test-list.scm
Log:
* test/uim-assertions.scm: define assertions that is
specialized to uim tests.
* test/uim-test.scm: define convenience module.
* test/util/test-list.scm: use assert-uim-*.
Added: trunk/test/uim-assertions.scm
==============================================================================
--- (empty file)
+++ trunk/test/uim-assertions.scm Fri Dec 12 06:15:53 2008
@@ -0,0 +1,56 @@
+;;; Copyright (c) 2004-2008 uim Project http://code.google.com/p/uim/
+;;;
+;;; All rights reserved.
+;;;
+;;; 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 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 HOLDERS 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.
+;;;
+
+(define-module test.uim-assertions
+ (use test.unit)
+ (use test.uim-test-utils-new)
+ (export-all))
+(select-module test.uim-assertions)
+
+(define (assert-uim-equal expected uim-expression)
+ (assert-equal expected (uim uim-expression))
+ #f)
+
+(define (assert-uim-raw-equal expected uim-expression-string)
+ (assert-equal expected (uim-raw uim-expression-string))
+ #f)
+
+(define (assert-uim-true uim-expression)
+ (assert-true (uim-bool uim-expression))
+ #f)
+
+(define (assert-uim-false uim-expression)
+ (assert-false (uim-bool uim-expression))
+ #f)
+
+(define (assert-uim-error uim-expression)
+ (assert-error (lambda () (uim uim-expression)))
+ #f)
+
+(provide "test/uim-assertions")
Added: trunk/test/uim-test.scm
==============================================================================
--- (empty file)
+++ trunk/test/uim-test.scm Fri Dec 12 06:15:53 2008
@@ -0,0 +1,34 @@
+;;; Copyright (c) 2004-2008 uim Project http://code.google.com/p/uim/
+;;;
+;;; All rights reserved.
+;;;
+;;; 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 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 HOLDERS 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.
+;;;
+
+(define-module test.uim-test
+ (extend test.uim-test-utils-new test.uim-assertions))
+(select-module test.uim-test)
+
+(provide "test/uim-test")
Modified: trunk/test/util/test-list.scm
==============================================================================
--- trunk/test/util/test-list.scm (original)
+++ trunk/test/util/test-list.scm Fri Dec 12 06:15:53 2008
@@ -29,7 +29,7 @@
(define-module test.util.test-list
(use test.unit.test-case)
- (use test.uim-test-utils-new))
+ (use test.uim-test))
(select-module test.util.test-list)
(define (setup)
@@ -40,693 +40,577 @@
(uim-test-teardown))
(define (test-truncate-list)
- (assert-equal ()
- (uim '(truncate-list () 0)))
- (assert-false (uim-bool '(truncate-list () 1)))
- (assert-equal ()
- (uim '(truncate-list '("foo" "bar" "baz") 0)))
- (assert-equal '("foo")
- (uim '(truncate-list '("foo" "bar" "baz") 1)))
- (assert-equal '("foo" "bar")
- (uim '(truncate-list '("foo" "bar" "baz") 2)))
- (assert-equal '("foo" "bar" "baz")
- (uim '(truncate-list '("foo" "bar" "baz") 3)))
- (assert-false (uim-bool '(truncate-list '("foo" "bar" "baz") 4)))
+ (assert-uim-equal '()
+ '(truncate-list () 0))
+ (assert-uim-false '(truncate-list () 1))
+ (assert-uim-equal '()
+ '(truncate-list '("foo" "bar" "baz") 0))
+ (assert-uim-equal '("foo")
+ '(truncate-list '("foo" "bar" "baz") 1))
+ (assert-uim-equal '("foo" "bar")
+ '(truncate-list '("foo" "bar" "baz") 2))
+ (assert-uim-equal '("foo" "bar" "baz")
+ '(truncate-list '("foo" "bar" "baz") 3))
+ (assert-uim-false '(truncate-list '("foo" "bar" "baz") 4))
#f)
(define (test-proc-or)
- (assert-false (uim-bool '(proc-or)))
- (assert-false (uim-bool '(proc-or #f)))
- (assert-true (uim-bool '(proc-or #t)))
- (assert-false (uim-bool '(proc-or #f #f)))
- (assert-true (uim-bool '(proc-or #f #t)))
- (assert-true (uim-bool '(proc-or #t #f)))
- (assert-true (uim-bool '(proc-or #t #t)))
- (assert-false (uim-bool '(proc-or #f #f #f)))
- (assert-true (uim-bool '(proc-or #f #f #t)))
- (assert-true (uim-bool '(proc-or #f #t #f)))
- (assert-true (uim-bool '(proc-or #f #t #t)))
- (assert-true (uim-bool '(proc-or #t #f #f)))
- (assert-true (uim-bool '(proc-or #t #f #t)))
- (assert-true (uim-bool '(proc-or #t #t #f)))
- (assert-true (uim-bool '(proc-or #t #t #t)))
- (assert-false (uim-bool '(apply proc-or ())))
- (assert-false (uim-bool '(apply proc-or '(#f))))
- (assert-true (uim-bool '(apply proc-or '(#t))))
- (assert-false (uim-bool '(apply proc-or '(#f #f))))
- (assert-true (uim-bool '(apply proc-or '(#f #t))))
- (assert-true (uim-bool '(apply proc-or '(#t #f))))
- (assert-true (uim-bool '(apply proc-or '(#t #t))))
- (assert-false (uim-bool '(apply proc-or '(#f #f #f))))
- (assert-true (uim-bool '(apply proc-or '(#f #f #t))))
- (assert-true (uim-bool '(apply proc-or '(#f #t #f))))
- (assert-true (uim-bool '(apply proc-or '(#f #t #t))))
- (assert-true (uim-bool '(apply proc-or '(#t #f #f))))
- (assert-true (uim-bool '(apply proc-or '(#t #f #t))))
- (assert-true (uim-bool '(apply proc-or '(#t #t #f))))
- (assert-true (uim-bool '(apply proc-or '(#t #t #t))))
+ (assert-uim-false '(proc-or))
+ (assert-uim-false '(proc-or #f))
+ (assert-uim-true '(proc-or #t))
+ (assert-uim-false '(proc-or #f #f))
+ (assert-uim-true '(proc-or #f #t))
+ (assert-uim-true '(proc-or #t #f))
+ (assert-uim-true '(proc-or #t #t))
+ (assert-uim-false '(proc-or #f #f #f))
+ (assert-uim-true '(proc-or #f #f #t))
+ (assert-uim-true '(proc-or #f #t #f))
+ (assert-uim-true '(proc-or #f #t #t))
+ (assert-uim-true '(proc-or #t #f #f))
+ (assert-uim-true '(proc-or #t #f #t))
+ (assert-uim-true '(proc-or #t #t #f))
+ (assert-uim-true '(proc-or #t #t #t))
+ (assert-uim-false '(apply proc-or ()))
+ (assert-uim-false '(apply proc-or '(#f)))
+ (assert-uim-true '(apply proc-or '(#t)))
+ (assert-uim-false '(apply proc-or '(#f #f)))
+ (assert-uim-true '(apply proc-or '(#f #t)))
+ (assert-uim-true '(apply proc-or '(#t #f)))
+ (assert-uim-true '(apply proc-or '(#t #t)))
+ (assert-uim-false '(apply proc-or '(#f #f #f)))
+ (assert-uim-true '(apply proc-or '(#f #f #t)))
+ (assert-uim-true '(apply proc-or '(#f #t #f)))
+ (assert-uim-true '(apply proc-or '(#f #t #t)))
+ (assert-uim-true '(apply proc-or '(#t #f #f)))
+ (assert-uim-true '(apply proc-or '(#t #f #t)))
+ (assert-uim-true '(apply proc-or '(#t #t #f)))
+ (assert-uim-true '(apply proc-or '(#t #t #t)))
#f)
(define (test-proc-and)
- (assert-true (uim-bool '(proc-and)))
- (assert-false (uim-bool '(proc-and #f)))
- (assert-true (uim-bool '(proc-and #t)))
- (assert-false (uim-bool '(proc-and #f #f)))
- (assert-false (uim-bool '(proc-and #f #t)))
- (assert-false (uim-bool '(proc-and #t #f)))
- (assert-true (uim-bool '(proc-and #t #t)))
- (assert-false (uim-bool '(proc-and #f #f #f)))
- (assert-false (uim-bool '(proc-and #f #f #t)))
- (assert-false (uim-bool '(proc-and #f #t #f)))
- (assert-false (uim-bool '(proc-and #f #t #t)))
- (assert-false (uim-bool '(proc-and #t #f #f)))
- (assert-false (uim-bool '(proc-and #t #f #t)))
- (assert-false (uim-bool '(proc-and #t #t #f)))
- (assert-true (uim-bool '(proc-and #t #t #t)))
- (assert-true (uim-bool '(apply proc-and ())))
- (assert-false (uim-bool '(apply proc-and '(#f))))
- (assert-true (uim-bool '(apply proc-and '(#t))))
- (assert-false (uim-bool '(apply proc-and '(#f #f))))
- (assert-false (uim-bool '(apply proc-and '(#f #t))))
- (assert-false (uim-bool '(apply proc-and '(#t #f))))
- (assert-true (uim-bool '(apply proc-and '(#t #t))))
- (assert-false (uim-bool '(apply proc-and '(#f #f #f))))
- (assert-false (uim-bool '(apply proc-and '(#f #f #t))))
- (assert-false (uim-bool '(apply proc-and '(#f #t #f))))
- (assert-false (uim-bool '(apply proc-and '(#f #t #t))))
- (assert-false (uim-bool '(apply proc-and '(#t #f #f))))
- (assert-false (uim-bool '(apply proc-and '(#t #f #t))))
- (assert-false (uim-bool '(apply proc-and '(#t #t #f))))
- (assert-true (uim-bool '(apply proc-and '(#t #t #t))))
+ (assert-uim-true '(proc-and))
+ (assert-uim-false '(proc-and #f))
+ (assert-uim-true '(proc-and #t))
+ (assert-uim-false '(proc-and #f #f))
+ (assert-uim-false '(proc-and #f #t))
+ (assert-uim-false '(proc-and #t #f))
+ (assert-uim-true '(proc-and #t #t))
+ (assert-uim-false '(proc-and #f #f #f))
+ (assert-uim-false '(proc-and #f #f #t))
+ (assert-uim-false '(proc-and #f #t #f))
+ (assert-uim-false '(proc-and #f #t #t))
+ (assert-uim-false '(proc-and #t #f #f))
+ (assert-uim-false '(proc-and #t #f #t))
+ (assert-uim-false '(proc-and #t #t #f))
+ (assert-uim-true '(proc-and #t #t #t))
+ (assert-uim-true '(apply proc-and ()))
+ (assert-uim-false '(apply proc-and '(#f)))
+ (assert-uim-true '(apply proc-and '(#t)))
+ (assert-uim-false '(apply proc-and '(#f #f)))
+ (assert-uim-false '(apply proc-and '(#f #t)))
+ (assert-uim-false '(apply proc-and '(#t #f)))
+ (assert-uim-true '(apply proc-and '(#t #t)))
+ (assert-uim-false '(apply proc-and '(#f #f #f)))
+ (assert-uim-false '(apply proc-and '(#f #f #t)))
+ (assert-uim-false '(apply proc-and '(#f #t #f)))
+ (assert-uim-false '(apply proc-and '(#f #t #t)))
+ (assert-uim-false '(apply proc-and '(#t #f #f)))
+ (assert-uim-false '(apply proc-and '(#t #f #t)))
+ (assert-uim-false '(apply proc-and '(#t #t #f)))
+ (assert-uim-true '(apply proc-and '(#t #t #t)))
#f)
;; See "Specification changes of utility procedures" of doc/COMPATIBILITY
(define (no-test-sublist-uim-1.4)
;; 0
- (assert-equal '(1)
- (uim '(sublist lst 0 0)))
- (assert-equal '(1 "2")
- (uim '(sublist lst 0 1)))
- (assert-equal '(1 "2" three)
- (uim '(sublist lst 0 2)))
- (assert-equal '(1 "2" three (4))
- (uim '(sublist lst 0 3)))
- (assert-equal '(1 "2" three (4) 5)
- (uim '(sublist lst 0 4)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8))
- (uim '(sublist lst 0 7)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 0 8)))
- (assert-error (lambda ()
- (uim '(sublist lst 0 9))))
+ (assert-uim-equal '(1)
+ '(sublist lst 0 0))
+ (assert-uim-equal '(1 "2")
+ '(sublist lst 0 1))
+ (assert-uim-equal '(1 "2" three)
+ '(sublist lst 0 2))
+ (assert-uim-equal '(1 "2" three (4))
+ '(sublist lst 0 3))
+ (assert-uim-equal '(1 "2" three (4) 5)
+ '(sublist lst 0 4))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8))
+ '(sublist lst 0 7))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
+ '(sublist lst 0 8))
+ (assert-uim-error '(sublist lst 0 9))
;; 1
- (assert-equal '()
- (uim '(sublist lst 1 0)))
- (assert-equal '("2")
- (uim '(sublist lst 1 1)))
- (assert-equal '("2" three)
- (uim '(sublist lst 1 2)))
- (assert-equal '("2" three (4))
- (uim '(sublist lst 1 3)))
- (assert-equal '("2" three (4) 5)
- (uim '(sublist lst 1 4)))
- (assert-equal '("2" three (4) 5 six "7" (8 8))
- (uim '(sublist lst 1 7)))
- (assert-equal '("2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 1 8)))
- (assert-error (lambda ()
- (uim '(sublist lst 1 9))))
+ (assert-uim-equal '()
+ '(sublist lst 1 0))
+ (assert-uim-equal '("2")
+ '(sublist lst 1 1))
+ (assert-uim-equal '("2" three)
+ '(sublist lst 1 2))
+ (assert-uim-equal '("2" three (4))
+ '(sublist lst 1 3))
+ (assert-uim-equal '("2" three (4) 5)
+ '(sublist lst 1 4))
+ (assert-uim-equal '("2" three (4) 5 six "7" (8 8))
+ '(sublist lst 1 7))
+ (assert-uim-equal '("2" three (4) 5 six "7" (8 8) -9)
+ '(sublist lst 1 8))
+ (assert-uim-error '(sublist lst 1 9))
;; 2
- (assert-error (lambda ()
- (uim '(sublist lst 2 0))))
- (assert-equal '()
- (uim '(sublist lst 2 1)))
- (assert-equal '(three)
- (uim '(sublist lst 2 2)))
- (assert-equal '(three (4))
- (uim '(sublist lst 2 3)))
- (assert-equal '(three (4) 5)
- (uim '(sublist lst 2 4)))
- (assert-equal '(three (4) 5 six "7" (8 8))
- (uim '(sublist lst 2 7)))
- (assert-equal '(three (4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 2 8)))
- (assert-error (lambda ()
- (uim '(sublist lst 2 9))))
+ (assert-uim-error '(sublist lst 2 0))
+ (assert-uim-equal '()
+ '(sublist lst 2 1))
+ (assert-uim-equal '(three)
+ '(sublist lst 2 2))
+ (assert-uim-equal '(three (4))
+ '(sublist lst 2 3))
+ (assert-uim-equal '(three (4) 5)
+ '(sublist lst 2 4))
+ (assert-uim-equal '(three (4) 5 six "7" (8 8))
+ '(sublist lst 2 7))
+ (assert-uim-equal '(three (4) 5 six "7" (8 8) -9)
+ '(sublist lst 2 8))
+ (assert-uim-error '(sublist lst 2 9))
;; 3
- (assert-error (lambda ()
- (uim '(sublist lst 3 0))))
- (assert-error (lambda ()
- (uim '(sublist lst 3 1))))
- (assert-equal '()
- (uim '(sublist lst 3 2)))
- (assert-equal '((4))
- (uim '(sublist lst 3 3)))
- (assert-equal '((4) 5)
- (uim '(sublist lst 3 4)))
- (assert-equal '((4) 5 six "7" (8 8))
- (uim '(sublist lst 3 7)))
- (assert-equal '((4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 3 8)))
- (assert-error (lambda ()
- (uim '(sublist lst 3 9))))
+ (assert-uim-error '(sublist lst 3 0))
+ (assert-uim-error '(sublist lst 3 1))
+ (assert-uim-equal '()
+ '(sublist lst 3 2))
+ (assert-uim-equal '((4))
+ '(sublist lst 3 3))
+ (assert-uim-equal '((4) 5)
+ '(sublist lst 3 4))
+ (assert-uim-equal '((4) 5 six "7" (8 8))
+ '(sublist lst 3 7))
+ (assert-uim-equal '((4) 5 six "7" (8 8) -9)
+ '(sublist lst 3 8))
+ (assert-uim-error '(sublist lst 3 9))
;; 8
- (assert-error (lambda ()
- (uim '(sublist lst 8 0))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 1))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 2))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 3))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 4))))
- (assert-equal '()
- (uim '(sublist lst 8 7)))
- (assert-equal '(-9)
- (uim '(sublist lst 8 8)))
- (assert-error (lambda ()
- (uim '(sublist lst 8 9))))
+ (assert-uim-error '(sublist lst 8 0))
+ (assert-uim-error '(sublist lst 8 1))
+ (assert-uim-error '(sublist lst 8 2))
+ (assert-uim-error '(sublist lst 8 3))
+ (assert-uim-error '(sublist lst 8 4))
+ (assert-uim-equal '()
+ '(sublist lst 8 7))
+ (assert-uim-equal '(-9)
+ '(sublist lst 8 8))
+ (assert-uim-error '(sublist lst 8 9))
;; 9
- (assert-error (lambda ()
- (uim '(sublist lst 9 0))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 1))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 2))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 3))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 4))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 7))))
- (assert-equal '()
- (uim '(sublist lst 9 8)))
- (assert-error (lambda ()
- (uim '(sublist lst 9 9))))
+ (assert-uim-error '(sublist lst 9 0))
+ (assert-uim-error '(sublist lst 9 1))
+ (assert-uim-error '(sublist lst 9 2))
+ (assert-uim-error '(sublist lst 9 3))
+ (assert-uim-error '(sublist lst 9 4))
+ (assert-uim-error '(sublist lst 9 7))
+ (assert-uim-equal '()
+ '(sublist lst 9 8))
+ (assert-uim-error '(sublist lst 9 9))
#f)
(define (no-test-sublist-rel-uim-1.4)
;; 0
- (assert-equal '(1)
- (uim '(sublist-rel lst 0 0)))
- (assert-equal '(1 "2")
- (uim '(sublist-rel lst 0 1)))
- (assert-equal '(1 "2" three)
- (uim '(sublist-rel lst 0 2)))
- (assert-equal '(1 "2" three (4))
- (uim '(sublist-rel lst 0 3)))
- (assert-equal '(1 "2" three (4) 5)
- (uim '(sublist-rel lst 0 4)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8))
- (uim '(sublist-rel lst 0 7)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 0 8)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 0 9))))
+ (assert-uim-equal '(1)
+ '(sublist-rel lst 0 0))
+ (assert-uim-equal '(1 "2")
+ '(sublist-rel lst 0 1))
+ (assert-uim-equal '(1 "2" three)
+ '(sublist-rel lst 0 2))
+ (assert-uim-equal '(1 "2" three (4))
+ '(sublist-rel lst 0 3))
+ (assert-uim-equal '(1 "2" three (4) 5)
+ '(sublist-rel lst 0 4))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8))
+ '(sublist-rel lst 0 7))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 0 8))
+ (assert-uim-error '(sublist-rel lst 0 9))
;; 1
- (assert-equal '("2")
- (uim '(sublist-rel lst 1 0)))
- (assert-equal '("2" three)
- (uim '(sublist-rel lst 1 1)))
- (assert-equal '("2" three (4))
- (uim '(sublist-rel lst 1 2)))
- (assert-equal '("2" three (4) 5)
- (uim '(sublist-rel lst 1 3)))
- (assert-equal '("2" three (4) 5 six)
- (uim '(sublist-rel lst 1 4)))
- (assert-equal '("2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 1 7)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 1 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 1 9))))
+ (assert-uim-equal '("2")
+ '(sublist-rel lst 1 0))
+ (assert-uim-equal '("2" three)
+ '(sublist-rel lst 1 1))
+ (assert-uim-equal '("2" three (4))
+ '(sublist-rel lst 1 2))
+ (assert-uim-equal '("2" three (4) 5)
+ '(sublist-rel lst 1 3))
+ (assert-uim-equal '("2" three (4) 5 six)
+ '(sublist-rel lst 1 4))
+ (assert-uim-equal '("2" three (4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 1 7))
+ (assert-uim-error '(sublist-rel lst 1 8))
+ (assert-uim-error '(sublist-rel lst 1 9))
;; 2
- (assert-equal '(three)
- (uim '(sublist-rel lst 2 0)))
- (assert-equal '(three (4))
- (uim '(sublist-rel lst 2 1)))
- (assert-equal '(three (4) 5)
- (uim '(sublist-rel lst 2 2)))
- (assert-equal '(three (4) 5 six)
- (uim '(sublist-rel lst 2 3)))
- (assert-equal '(three (4) 5 six "7")
- (uim '(sublist-rel lst 2 4)))
- (assert-equal '(three (4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 2 6)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 2 7))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 2 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 2 9))))
+ (assert-uim-equal '(three)
+ '(sublist-rel lst 2 0))
+ (assert-uim-equal '(three (4))
+ '(sublist-rel lst 2 1))
+ (assert-uim-equal '(three (4) 5)
+ '(sublist-rel lst 2 2))
+ (assert-uim-equal '(three (4) 5 six)
+ '(sublist-rel lst 2 3))
+ (assert-uim-equal '(three (4) 5 six "7")
+ '(sublist-rel lst 2 4))
+ (assert-uim-equal '(three (4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 2 6))
+ (assert-uim-error '(sublist-rel lst 2 7))
+ (assert-uim-error '(sublist-rel lst 2 8))
+ (assert-uim-error '(sublist-rel lst 2 9))
;; 3
- (assert-equal '((4))
- (uim '(sublist-rel lst 3 0)))
- (assert-equal '((4) 5)
- (uim '(sublist-rel lst 3 1)))
- (assert-equal '((4) 5 six)
- (uim '(sublist-rel lst 3 2)))
- (assert-equal '((4) 5 six "7")
- (uim '(sublist-rel lst 3 3)))
- (assert-equal '((4) 5 six "7" (8 8))
- (uim '(sublist-rel lst 3 4)))
- (assert-equal '((4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 3 5)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 6))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 7))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 9))))
+ (assert-uim-equal '((4))
+ '(sublist-rel lst 3 0))
+ (assert-uim-equal '((4) 5)
+ '(sublist-rel lst 3 1))
+ (assert-uim-equal '((4) 5 six)
+ '(sublist-rel lst 3 2))
+ (assert-uim-equal '((4) 5 six "7")
+ '(sublist-rel lst 3 3))
+ (assert-uim-equal '((4) 5 six "7" (8 8))
+ '(sublist-rel lst 3 4))
+ (assert-uim-equal '((4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 3 5))
+ (assert-uim-error '(sublist-rel lst 3 6))
+ (assert-uim-error '(sublist-rel lst 3 7))
+ (assert-uim-error '(sublist-rel lst 3 8))
+ (assert-uim-error '(sublist-rel lst 3 9))
;; 8
- (assert-equal '(-9)
- (uim '(sublist-rel lst 8 0)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 1))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 2))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 3))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 4))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 5))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 6))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 7))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 9))))
+ (assert-uim-equal '(-9)
+ '(sublist-rel lst 8 0))
+ (assert-uim-error '(sublist-rel lst 8 1))
+ (assert-uim-error '(sublist-rel lst 8 2))
+ (assert-uim-error '(sublist-rel lst 8 3))
+ (assert-uim-error '(sublist-rel lst 8 4))
+ (assert-uim-error '(sublist-rel lst 8 5))
+ (assert-uim-error '(sublist-rel lst 8 6))
+ (assert-uim-error '(sublist-rel lst 8 7))
+ (assert-uim-error '(sublist-rel lst 8 8))
+ (assert-uim-error '(sublist-rel lst 8 9))
;; 9
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 0))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 1))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 2))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 3))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 4))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 5))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 6))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 7))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 9))))
+ (assert-uim-error '(sublist-rel lst 9 0))
+ (assert-uim-error '(sublist-rel lst 9 1))
+ (assert-uim-error '(sublist-rel lst 9 2))
+ (assert-uim-error '(sublist-rel lst 9 3))
+ (assert-uim-error '(sublist-rel lst 9 4))
+ (assert-uim-error '(sublist-rel lst 9 5))
+ (assert-uim-error '(sublist-rel lst 9 6))
+ (assert-uim-error '(sublist-rel lst 9 7))
+ (assert-uim-error '(sublist-rel lst 9 8))
+ (assert-uim-error '(sublist-rel lst 9 9))
#f)
;; See "Specification changes of utility procedures" of doc/COMPATIBILITY
(define (test-sublist-uim-1.5)
;; 0
- (assert-equal '()
- (uim '(sublist lst 0 0)))
- (assert-equal '(1)
- (uim '(sublist lst 0 1)))
- (assert-equal '(1 "2")
- (uim '(sublist lst 0 2)))
- (assert-equal '(1 "2" three)
- (uim '(sublist lst 0 3)))
- (assert-equal '(1 "2" three (4))
- (uim '(sublist lst 0 4)))
- (assert-equal '(1 "2" three (4) 5 six "7")
- (uim '(sublist lst 0 7)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8))
- (uim '(sublist lst 0 8)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 0 9)))
- (assert-error (lambda ()
- (uim '(sublist lst 0 10))))
+ (assert-uim-equal '()
+ '(sublist lst 0 0))
+ (assert-uim-equal '(1)
+ '(sublist lst 0 1))
+ (assert-uim-equal '(1 "2")
+ '(sublist lst 0 2))
+ (assert-uim-equal '(1 "2" three)
+ '(sublist lst 0 3))
+ (assert-uim-equal '(1 "2" three (4))
+ '(sublist lst 0 4))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7")
+ '(sublist lst 0 7))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8))
+ '(sublist lst 0 8))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
+ '(sublist lst 0 9))
+ (assert-uim-error '(sublist lst 0 10))
;; 1
- (assert-error (lambda ()
- (uim '(sublist lst 1 0))))
- (assert-equal '()
- (uim '(sublist lst 1 1)))
- (assert-equal '("2")
- (uim '(sublist lst 1 2)))
- (assert-equal '("2" three)
- (uim '(sublist lst 1 3)))
- (assert-equal '("2" three (4))
- (uim '(sublist lst 1 4)))
- (assert-equal '("2" three (4) 5 six "7")
- (uim '(sublist lst 1 7)))
- (assert-equal '("2" three (4) 5 six "7" (8 8))
- (uim '(sublist lst 1 8)))
- (assert-equal '("2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 1 9)))
- (assert-error (lambda ()
- (uim '(sublist lst 1 10))))
+ (assert-uim-error '(sublist lst 1 0))
+ (assert-uim-equal '()
+ '(sublist lst 1 1))
+ (assert-uim-equal '("2")
+ '(sublist lst 1 2))
+ (assert-uim-equal '("2" three)
+ '(sublist lst 1 3))
+ (assert-uim-equal '("2" three (4))
+ '(sublist lst 1 4))
+ (assert-uim-equal '("2" three (4) 5 six "7")
+ '(sublist lst 1 7))
+ (assert-uim-equal '("2" three (4) 5 six "7" (8 8))
+ '(sublist lst 1 8))
+ (assert-uim-equal '("2" three (4) 5 six "7" (8 8) -9)
+ '(sublist lst 1 9))
+ (assert-uim-error '(sublist lst 1 10))
;; 2
- (assert-error (lambda ()
- (uim '(sublist lst 2 0))))
- (assert-error (lambda ()
- (uim '(sublist lst 2 1))))
- (assert-equal '()
- (uim '(sublist lst 2 2)))
- (assert-equal '(three)
- (uim '(sublist lst 2 3)))
- (assert-equal '(three (4))
- (uim '(sublist lst 2 4)))
- (assert-equal '(three (4) 5 six "7")
- (uim '(sublist lst 2 7)))
- (assert-equal '(three (4) 5 six "7" (8 8))
- (uim '(sublist lst 2 8)))
- (assert-equal '(three (4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 2 9)))
- (assert-error (lambda ()
- (uim '(sublist lst 2 10))))
+ (assert-uim-error '(sublist lst 2 0))
+ (assert-uim-error '(sublist lst 2 1))
+ (assert-uim-equal '()
+ '(sublist lst 2 2))
+ (assert-uim-equal '(three)
+ '(sublist lst 2 3))
+ (assert-uim-equal '(three (4))
+ '(sublist lst 2 4))
+ (assert-uim-equal '(three (4) 5 six "7")
+ '(sublist lst 2 7))
+ (assert-uim-equal '(three (4) 5 six "7" (8 8))
+ '(sublist lst 2 8))
+ (assert-uim-equal '(three (4) 5 six "7" (8 8) -9)
+ '(sublist lst 2 9))
+ (assert-uim-error '(sublist lst 2 10))
;; 3
- (assert-error (lambda ()
- (uim '(sublist lst 3 0))))
- (assert-error (lambda ()
- (uim '(sublist lst 3 1))))
- (assert-error (lambda ()
- (uim '(sublist lst 3 2))))
- (assert-equal '()
- (uim '(sublist lst 3 3)))
- (assert-equal '((4))
- (uim '(sublist lst 3 4)))
- (assert-equal '((4) 5)
- (uim '(sublist lst 3 5)))
- (assert-equal '((4) 5 six "7" (8 8))
- (uim '(sublist lst 3 8)))
- (assert-equal '((4) 5 six "7" (8 8) -9)
- (uim '(sublist lst 3 9)))
- (assert-error (lambda ()
- (uim '(sublist lst 3 10))))
+ (assert-uim-error '(sublist lst 3 0))
+ (assert-uim-error '(sublist lst 3 1))
+ (assert-uim-error '(sublist lst 3 2))
+ (assert-uim-equal '()
+ '(sublist lst 3 3))
+ (assert-uim-equal '((4))
+ '(sublist lst 3 4))
+ (assert-uim-equal '((4) 5)
+ '(sublist lst 3 5))
+ (assert-uim-equal '((4) 5 six "7" (8 8))
+ '(sublist lst 3 8))
+ (assert-uim-equal '((4) 5 six "7" (8 8) -9)
+ '(sublist lst 3 9))
+ (assert-uim-error '(sublist lst 3 10))
;; 8
- (assert-error (lambda ()
- (uim '(sublist lst 8 0))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 1))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 2))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 3))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 4))))
- (assert-error (lambda ()
- (uim '(sublist lst 8 7))))
- (assert-equal '()
- (uim '(sublist lst 8 8)))
- (assert-equal '(-9)
- (uim '(sublist lst 8 9)))
- (assert-error (lambda ()
- (uim '(sublist lst 8 10))))
+ (assert-uim-error '(sublist lst 8 0))
+ (assert-uim-error '(sublist lst 8 1))
+ (assert-uim-error '(sublist lst 8 2))
+ (assert-uim-error '(sublist lst 8 3))
+ (assert-uim-error '(sublist lst 8 4))
+ (assert-uim-error '(sublist lst 8 7))
+ (assert-uim-equal '()
+ '(sublist lst 8 8))
+ (assert-uim-equal '(-9)
+ '(sublist lst 8 9))
+ (assert-uim-error '(sublist lst 8 10))
;; 9
- (assert-error (lambda ()
- (uim '(sublist lst 9 0))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 1))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 2))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 3))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 4))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 7))))
- (assert-error (lambda ()
- (uim '(sublist lst 9 8))))
- (assert-equal '()
- (uim '(sublist lst 9 9)))
- (assert-error (lambda ()
- (uim '(sublist lst 9 10))))
+ (assert-uim-error '(sublist lst 9 0))
+ (assert-uim-error '(sublist lst 9 1))
+ (assert-uim-error '(sublist lst 9 2))
+ (assert-uim-error '(sublist lst 9 3))
+ (assert-uim-error '(sublist lst 9 4))
+ (assert-uim-error '(sublist lst 9 7))
+ (assert-uim-error '(sublist lst 9 8))
+ (assert-uim-equal '()
+ '(sublist lst 9 9))
+ (assert-uim-error '(sublist lst 9 10))
#f)
(define (test-sublist-rel-uim-1.5)
;; 0
- (assert-error (lambda ()
- (uim '(sublist-rel lst 0 -1))))
- (assert-equal '()
- (uim '(sublist-rel lst 0 0)))
- (assert-equal '(1)
- (uim '(sublist-rel lst 0 1)))
- (assert-equal '(1 "2")
- (uim '(sublist-rel lst 0 2)))
- (assert-equal '(1 "2" three)
- (uim '(sublist-rel lst 0 3)))
- (assert-equal '(1 "2" three (4))
- (uim '(sublist-rel lst 0 4)))
- (assert-equal '(1 "2" three (4) 5)
- (uim '(sublist-rel lst 0 5)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8))
- (uim '(sublist-rel lst 0 8)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 0 9)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 0 10))))
+ (assert-uim-error '(sublist-rel lst 0 -1))
+ (assert-uim-equal '()
+ '(sublist-rel lst 0 0))
+ (assert-uim-equal '(1)
+ '(sublist-rel lst 0 1))
+ (assert-uim-equal '(1 "2")
+ '(sublist-rel lst 0 2))
+ (assert-uim-equal '(1 "2" three)
+ '(sublist-rel lst 0 3))
+ (assert-uim-equal '(1 "2" three (4))
+ '(sublist-rel lst 0 4))
+ (assert-uim-equal '(1 "2" three (4) 5)
+ '(sublist-rel lst 0 5))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8))
+ '(sublist-rel lst 0 8))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 0 9))
+ (assert-uim-error '(sublist-rel lst 0 10))
;; 1
- (assert-error (lambda ()
- (uim '(sublist-rel lst 1 -1))))
- (assert-equal '()
- (uim '(sublist-rel lst 1 0)))
- (assert-equal '("2")
- (uim '(sublist-rel lst 1 1)))
- (assert-equal '("2" three)
- (uim '(sublist-rel lst 1 2)))
- (assert-equal '("2" three (4))
- (uim '(sublist-rel lst 1 3)))
- (assert-equal '("2" three (4) 5)
- (uim '(sublist-rel lst 1 4)))
- (assert-equal '("2" three (4) 5 six)
- (uim '(sublist-rel lst 1 5)))
- (assert-equal '("2" three (4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 1 8)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 1 9))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 1 10))))
+ (assert-uim-error '(sublist-rel lst 1 -1))
+ (assert-uim-equal '()
+ '(sublist-rel lst 1 0))
+ (assert-uim-equal '("2")
+ '(sublist-rel lst 1 1))
+ (assert-uim-equal '("2" three)
+ '(sublist-rel lst 1 2))
+ (assert-uim-equal '("2" three (4))
+ '(sublist-rel lst 1 3))
+ (assert-uim-equal '("2" three (4) 5)
+ '(sublist-rel lst 1 4))
+ (assert-uim-equal '("2" three (4) 5 six)
+ '(sublist-rel lst 1 5))
+ (assert-uim-equal '("2" three (4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 1 8))
+ (assert-uim-error '(sublist-rel lst 1 9))
+ (assert-uim-error '(sublist-rel lst 1 10))
;; 2
- (assert-error (lambda ()
- (uim '(sublist-rel lst 2 -1))))
- (assert-equal '()
- (uim '(sublist-rel lst 2 0)))
- (assert-equal '(three)
- (uim '(sublist-rel lst 2 1)))
- (assert-equal '(three (4))
- (uim '(sublist-rel lst 2 2)))
- (assert-equal '(three (4) 5)
- (uim '(sublist-rel lst 2 3)))
- (assert-equal '(three (4) 5 six)
- (uim '(sublist-rel lst 2 4)))
- (assert-equal '(three (4) 5 six "7")
- (uim '(sublist-rel lst 2 5)))
- (assert-equal '(three (4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 2 7)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 2 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 2 9))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 2 10))))
+ (assert-uim-error '(sublist-rel lst 2 -1))
+ (assert-uim-equal '()
+ '(sublist-rel lst 2 0))
+ (assert-uim-equal '(three)
+ '(sublist-rel lst 2 1))
+ (assert-uim-equal '(three (4))
+ '(sublist-rel lst 2 2))
+ (assert-uim-equal '(three (4) 5)
+ '(sublist-rel lst 2 3))
+ (assert-uim-equal '(three (4) 5 six)
+ '(sublist-rel lst 2 4))
+ (assert-uim-equal '(three (4) 5 six "7")
+ '(sublist-rel lst 2 5))
+ (assert-uim-equal '(three (4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 2 7))
+ (assert-uim-error '(sublist-rel lst 2 8))
+ (assert-uim-error '(sublist-rel lst 2 9))
+ (assert-uim-error '(sublist-rel lst 2 10))
;; 3
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 -1))))
- (assert-equal '()
- (uim '(sublist-rel lst 3 0)))
- (assert-equal '((4))
- (uim '(sublist-rel lst 3 1)))
- (assert-equal '((4) 5)
- (uim '(sublist-rel lst 3 2)))
- (assert-equal '((4) 5 six)
- (uim '(sublist-rel lst 3 3)))
- (assert-equal '((4) 5 six "7")
- (uim '(sublist-rel lst 3 4)))
- (assert-equal '((4) 5 six "7" (8 8))
- (uim '(sublist-rel lst 3 5)))
- (assert-equal '((4) 5 six "7" (8 8) -9)
- (uim '(sublist-rel lst 3 6)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 7))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 3 9))))
+ (assert-uim-error '(sublist-rel lst 3 -1))
+ (assert-uim-equal '()
+ '(sublist-rel lst 3 0))
+ (assert-uim-equal '((4))
+ '(sublist-rel lst 3 1))
+ (assert-uim-equal '((4) 5)
+ '(sublist-rel lst 3 2))
+ (assert-uim-equal '((4) 5 six)
+ '(sublist-rel lst 3 3))
+ (assert-uim-equal '((4) 5 six "7")
+ '(sublist-rel lst 3 4))
+ (assert-uim-equal '((4) 5 six "7" (8 8))
+ '(sublist-rel lst 3 5))
+ (assert-uim-equal '((4) 5 six "7" (8 8) -9)
+ '(sublist-rel lst 3 6))
+ (assert-uim-error '(sublist-rel lst 3 7))
+ (assert-uim-error '(sublist-rel lst 3 8))
+ (assert-uim-error '(sublist-rel lst 3 9))
;; 8
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 -1))))
- (assert-equal '()
- (uim '(sublist-rel lst 8 0)))
- (assert-equal '(-9)
- (uim '(sublist-rel lst 8 1)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 2))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 3))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 4))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 5))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 6))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 7))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 8 9))))
+ (assert-uim-error '(sublist-rel lst 8 -1))
+ (assert-uim-equal '()
+ '(sublist-rel lst 8 0))
+ (assert-uim-equal '(-9)
+ '(sublist-rel lst 8 1))
+ (assert-uim-error '(sublist-rel lst 8 2))
+ (assert-uim-error '(sublist-rel lst 8 3))
+ (assert-uim-error '(sublist-rel lst 8 4))
+ (assert-uim-error '(sublist-rel lst 8 5))
+ (assert-uim-error '(sublist-rel lst 8 6))
+ (assert-uim-error '(sublist-rel lst 8 7))
+ (assert-uim-error '(sublist-rel lst 8 8))
+ (assert-uim-error '(sublist-rel lst 8 9))
;; 9
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 -1))))
- (assert-equal '()
- (uim '(sublist-rel lst 9 0)))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 1))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 2))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 3))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 4))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 5))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 6))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 7))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 8))))
- (assert-error (lambda ()
- (uim '(sublist-rel lst 9 9))))
+ (assert-uim-error '(sublist-rel lst 9 -1))
+ (assert-uim-equal '()
+ '(sublist-rel lst 9 0))
+ (assert-uim-error '(sublist-rel lst 9 1))
+ (assert-uim-error '(sublist-rel lst 9 2))
+ (assert-uim-error '(sublist-rel lst 9 3))
+ (assert-uim-error '(sublist-rel lst 9 4))
+ (assert-uim-error '(sublist-rel lst 9 5))
+ (assert-uim-error '(sublist-rel lst 9 6))
+ (assert-uim-error '(sublist-rel lst 9 7))
+ (assert-uim-error '(sublist-rel lst 9 8))
+ (assert-uim-error '(sublist-rel lst 9 9))
#f)
(define (test-list-head)
- (assert-equal ()
- (uim '(list-head lst 0)))
- (assert-equal '(1)
- (uim '(list-head lst 1)))
- (assert-equal '(1 "2")
- (uim '(list-head lst 2)))
- (assert-equal '(1 "2" three)
- (uim '(list-head lst 3)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8))
- (uim '(list-head lst 8)))
- (assert-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
- (uim '(list-head lst 9)))
- (assert-error (lambda ()
- (uim '(list-head lst 10))))
- (assert-error (lambda ()
- (uim '(list-head lst -1))))
+ (assert-uim-equal '()
+ '(list-head lst 0))
+ (assert-uim-equal '(1)
+ '(list-head lst 1))
+ (assert-uim-equal '(1 "2")
+ '(list-head lst 2))
+ (assert-uim-equal '(1 "2" three)
+ '(list-head lst 3))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8))
+ '(list-head lst 8))
+ (assert-uim-equal '(1 "2" three (4) 5 six "7" (8 8) -9)
+ '(list-head lst 9))
+ (assert-uim-error '(list-head lst 10))
+ (assert-uim-error '(list-head lst -1))
#f)
(define (test-alist-replace)
(uim '(define alist ()))
(uim '(set! alist (alist-replace '(first 1 "1") alist)))
- (assert-equal '((first 1 "1"))
- (uim 'alist))
+ (assert-uim-equal '((first 1 "1"))
+ 'alist)
(uim '(set! alist (alist-replace '(second 2 "2") alist)))
- (assert-equal '((second 2 "2") (first 1 "1"))
- (uim 'alist))
+ (assert-uim-equal '((second 2 "2") (first 1 "1"))
+ 'alist)
(uim '(set! alist (alist-replace '(third 3 "3") alist)))
- (assert-equal '((third 3 "3") (second 2 "2") (first 1 "1"))
- (uim 'alist))
+ (assert-uim-equal '((third 3 "3") (second 2 "2") (first 1 "1"))
+ 'alist)
(uim '(set! alist (alist-replace '(second two "two") alist)))
- (assert-equal '((third 3 "3") (second two "two") (first 1 "1"))
- (uim 'alist))
+ (assert-uim-equal '((third 3 "3") (second two "two") (first 1 "1"))
+ 'alist)
#f)
(define (test-list-join)
- (assert-equal ()
- (uim '(list-join () ())))
- (assert-equal '(())
- (uim '(list-join '(()) ())))
- (assert-equal '(1)
- (uim '(list-join '(1) ())))
- (assert-equal '(() () ())
- (uim '(list-join '(() ()) ())))
- (assert-equal '(1 () 2)
- (uim '(list-join '(1 2) ())))
- (assert-equal '(1 () 2 () 3)
- (uim '(list-join '(1 2 3) ())))
- (assert-equal '(one () two () three)
- (uim '(list-join '(one two three) ())))
- (assert-equal '("1" () "2" () "3")
- (uim '(list-join '("1" "2" "3") ())))
- (assert-equal '(() () () () ())
- (uim '(list-join '(() () ()) ())))
-
- (assert-equal ()
- (uim '(list-join () "/")))
- (assert-equal '(())
- (uim '(list-join '(()) "/")))
- (assert-equal '(1)
- (uim '(list-join '(1) "/")))
- (assert-equal '(() "/" ())
- (uim '(list-join '(() ()) "/")))
- (assert-equal '(1 "/" 2)
- (uim '(list-join '(1 2) "/")))
- (assert-equal '(1 "/" 2 "/" 3)
- (uim '(list-join '(1 2 3) "/")))
- (assert-equal '(one "/" two "/" three)
- (uim '(list-join '(one two three) "/")))
- (assert-equal '("1" "/" "2" "/" "3")
- (uim '(list-join '("1" "2" "3") "/")))
- (assert-equal '(() "/" () "/" ())
- (uim '(list-join '(() () ()) "/")))
+ (assert-uim-equal '()
+ '(list-join () ()))
+ (assert-uim-equal '(())
+ '(list-join '(()) ()))
+ (assert-uim-equal '(1)
+ '(list-join '(1) ()))
+ (assert-uim-equal '(() () ())
+ '(list-join '(() ()) ()))
+ (assert-uim-equal '(1 () 2)
+ '(list-join '(1 2) ()))
+ (assert-uim-equal '(1 () 2 () 3)
+ '(list-join '(1 2 3) ()))
+ (assert-uim-equal '(one () two () three)
+ '(list-join '(one two three) ()))
+ (assert-uim-equal '("1" () "2" () "3")
+ '(list-join '("1" "2" "3") ()))
+ (assert-uim-equal '(() () () () ())
+ '(list-join '(() () ()) ()))
+
+ (assert-uim-equal '()
+ '(list-join () "/"))
+ (assert-uim-equal '(())
+ '(list-join '(()) "/"))
+ (assert-uim-equal '(1)
+ '(list-join '(1) "/"))
+ (assert-uim-equal '(() "/" ())
+ '(list-join '(() ()) "/"))
+ (assert-uim-equal '(1 "/" 2)
+ '(list-join '(1 2) "/"))
+ (assert-uim-equal '(1 "/" 2 "/" 3)
+ '(list-join '(1 2 3) "/"))
+ (assert-uim-equal '(one "/" two "/" three)
+ '(list-join '(one two three) "/"))
+ (assert-uim-equal '("1" "/" "2" "/" "3")
+ '(list-join '("1" "2" "3") "/"))
+ (assert-uim-equal '(() "/" () "/" ())
+ '(list-join '(() () ()) "/"))
#f)
(define (test-string-join)
- (assert-equal ""
- (uim '(string-join () ())))
- (assert-error (lambda ()
- (uim '(string-join '(()) ()))))
- (assert-error (lambda ()
- (uim '(string-join '(1) ()))))
- (assert-error (lambda ()
- (uim '(string-join '(() ()) ()))))
- (assert-error (lambda ()
- (uim '(string-join '(1 2) ()))))
- (assert-error (lambda ()
- (uim '(string-join '(1 2 3) ()))))
- (assert-error (lambda ()
- (uim '(string-join '(one two three) ()))))
- (assert-error (lambda ()
- (uim '(string-join '("1" "2" "3") ()))))
- (assert-error (lambda ()
- (uim '(string-join '(() () ()) ()))))
-
- (assert-equal ""
- (uim '(string-join () "/")))
- (assert-equal ""
- (uim '(string-join '("") "/")))
- (assert-equal "1"
- (uim '(string-join '("1") "/")))
- (assert-equal "1/2"
- (uim '(string-join '("1" "2") "/")))
- (assert-equal "1/2/3"
- (uim '(string-join '("1" "2" "3") "/")))
-
- (assert-equal ""
- (uim '(string-join () "-sep-")))
- (assert-equal ""
- (uim '(string-join '("") "-sep-")))
- (assert-equal "1"
- (uim '(string-join '("1") "-sep-")))
- (assert-equal "1-sep-2"
- (uim '(string-join '("1" "2") "-sep-")))
- (assert-equal "1-sep-2-sep-3"
- (uim '(string-join '("1" "2" "3") "-sep-")))
+ (assert-uim-equal ""
+ '(string-join () ()))
+ (assert-uim-error '(string-join '(()) ()))
+ (assert-uim-error '(string-join '(1) ()))
+ (assert-uim-error '(string-join '(() ()) ()))
+ (assert-uim-error '(string-join '(1 2) ()))
+ (assert-uim-error '(string-join '(1 2 3) ()))
+ (assert-uim-error '(string-join '(one two three) ()))
+ (assert-uim-error '(string-join '("1" "2" "3") ()))
+ (assert-uim-error '(string-join '(() () ()) ()))
+
+ (assert-uim-equal ""
+ '(string-join () "/"))
+ (assert-uim-equal ""
+ '(string-join '("") "/"))
+ (assert-uim-equal "1"
+ '(string-join '("1") "/"))
+ (assert-uim-equal "1/2"
+ '(string-join '("1" "2") "/"))
+ (assert-uim-equal "1/2/3"
+ '(string-join '("1" "2" "3") "/"))
+
+ (assert-uim-equal ""
+ '(string-join () "-sep-"))
+ (assert-uim-equal ""
+ '(string-join '("") "-sep-"))
+ (assert-uim-equal "1"
+ '(string-join '("1") "-sep-"))
+ (assert-uim-equal "1-sep-2"
+ '(string-join '("1" "2") "-sep-"))
+ (assert-uim-equal "1-sep-2-sep-3"
+ '(string-join '("1" "2" "3") "-sep-"))
#f)
(define (test-string-append-map)
- (assert-equal ""
- (uim '(string-append-map car ())))
- (assert-equal "c"
- (uim '(string-append-map car '(("c" "C")))))
- (assert-equal "ca"
- (uim '(string-append-map car '(("c" "C") ("a" "A")))))
- (assert-equal "car"
- (uim '(string-append-map car '(("c" "C") ("a" "A")
("r" "R")))))
+ (assert-uim-equal ""
+ '(string-append-map car ()))
+ (assert-uim-equal "c"
+ '(string-append-map car '(("c" "C"))))
+ (assert-uim-equal "ca"
+ '(string-append-map car '(("c" "C") ("a" "A"))))
+ (assert-uim-equal "car"
+ '(string-append-map car '(("c" "C") ("a" "A")
("r" "R"))))
#f)
(provide "test/util/test-list")
