Changeset 8490 in project


Ignore:
Timestamp:
02/15/08 22:57:07 (12 years ago)
Author:
Kon Lovett
Message:

Added 'insist' form.

Location:
release/3/testbase
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • release/3/testbase/testbase-hygienic.scm

    r7856 r8490  
    2424    [(_ W W/O)
    2525      (if (tb$test-with-option 'test::timing)
    26         #'W
    27         #'W/O)] ) )
     26          #'W
     27          #'W/O)] ) )
    2828
    2929(define-syntax (tbm$if-filtering X)
     
    3131    [(_ W W/O)
    3232      (if (tb$test-with-option 'test::filtering)
    33         #'W
    34         #'W/O)] ) )
     33          #'W
     34          #'W/O)] ) )
    3535
    3636(define-syntax (tbm$if-catching X)
     
    3838    [(_ W W/O)
    3939      (if (tb$test-with-option 'test::catching)
    40         #'W
    41         #'W/O)] ) )
     40          #'W
     41          #'W/O)] ) )
    4242
    4343(define-syntax (tbm$if-selecting X)
     
    4545    [(_ W W/O)
    4646      (if (tb$test-with-option 'test::selecting)
    47         #'W
    48         #'W/O)] ) )
     47          #'W
     48          #'W/O)] ) )
    4949
    5050(define-syntax (tbm$if-limiting X)
     
    5252    [(_ W W/O)
    5353      (if (tb$test-with-option 'test::limiting)
    54         #'W
    55         #'W/O)] ) )
     54          #'W
     55          #'W/O)] ) )
    5656
    5757;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    8989
    9090(define-for-syntax (tbs$conc . objs)
    91   (apply string-append
    92     (map (lambda (x) (->string (syntax-object->datum x))) objs)) )
     91  (apply string-append (map (lambda (x) (->string (syntax-object->datum x))) objs)) )
    9392
    9493(define-for-syntax (tbs$conc->str-synobj sk . objs)
     
    9796(define-for-syntax (tbs$conc->sym-synobj sk . syms)
    9897  (datum->syntax-object sk (string->symbol (apply tbs$conc syms))) )
     98
     99;; Returns the prefix string from a predicate symbol
     100
     101(define-for-syntax (tbs$suffstr-synobj sk pred)
     102  (let* ([str (->string (syntax-object->datum pred))]
     103         [end (fx- (string-length str) 1)])
     104    (if (char=? #\? (string-ref str end))
     105        (substring str 0 end)
     106        str) ) )
     107
     108;; Returns the prefix symbol from a predicate symbol
     109
     110(define-for-syntax (tbs$suffsym-synobj sk pred)
     111  (datum->syntax-object sk (string->symbol (tbs$suffstr-synobj sk pred))) )
    99112
    100113;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    116129            (let-syntax ([eval-test
    117130                          (syntax-rules ()
    118                             [(_ (EXPECTED EXPR))
     131                            [(_ (EXPT EXPR))
    119132                              (tb$expt2 STATE #f '()
    120133                                "equal" (cut tb$exptpred2 <> <> equal?)
    121                                 EXPECTED 'EXPR
     134                                EXPT 'EXPR
    122135                                (tb$trythkctch STATE (lambda () EXPR)))])])
    123136              (tb$tstbdy STATE
     
    142155    [(_ NAME (PROC ARG0 ...) ...)
    143156      (if (tb$rnmdbtch?)
    144         (begin (PROC ARG0 ...) ...)
    145         (tb$tstrepl NAME))] ) )
     157          (begin (PROC ARG0 ...) ...)
     158          (tb$tstrepl NAME))] ) )
    146159
    147160;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    220233                      '((lambda () TERM0 ...)))
    221234                    ; Turn on resource limiting, if needed
    222                     (if (tb$eval-mode? STATE)
    223                       (tbm$if-limiting (tb$lmgbeg STATE) (void)))
     235                    (when (tb$eval-mode? STATE)
     236                      (tbm$if-limiting (tb$lmgbeg STATE) (void)) )
    224237                    ; Evaluate the clauses
    225238                    (let ([results (tbm$eval-clauses-lr STATE CLAUSE0 ...)])
    226239                      ; Turn off resource limiting, if needed
    227                       (if (tb$eval-mode? STATE)
    228                         (tbm$if-limiting (tb$lmgend STATE) (void)))
     240                      (when (tb$eval-mode? STATE)
     241                        (tbm$if-limiting (tb$lmgend STATE) (void)) )
    229242                      ; Return the test results
    230243                      results ) ) ) ) ) ) ) )] ) )
     
    242255          (let ([STATE (tb$makstt '(VAR0 ...) 'PRCVAR TSTNAM)])
    243256            (lambda args
    244               (cond
    245                 [(null? args)
    246                   (tb$errtstprcargs STATE args)]
    247                 [(eq? tb$stttg (car args))
    248                   STATE]
    249                 [else
    250                   (receive [tstnam VAR0 ...] (tb$chkacttstprcargs STATE args)
    251                     (tbm$define-test-body STATE DTOR ESCR tstnam
    252                       (INIT0 ...) (TERM0 ...) CLAUSE0 ...))]))))
     257              (cond [(null? args)
     258                      (tb$errtstprcargs STATE args)]
     259                    [(eq? tb$stttg (car args))
     260                      STATE]
     261                    [else
     262                      (receive [tstnam VAR0 ...] (tb$chkacttstprcargs STATE args)
     263                        (tbm$define-test-body STATE DTOR ESCR tstnam
     264                          (INIT0 ...) (TERM0 ...) CLAUSE0 ...))]))))
    253265        (tb$newtstprc 'define-test PRCVAR))]
    254266
     
    260272          (let ([STATE (tb$makstt '() 'PRCVAR TSTNAM)])
    261273            (lambda args
    262               (cond
    263                 [(null? args)
    264                   (tbm$define-test-body STATE DTOR ESCR TSTNAM
    265                     (INIT0 ...) (TERM0 ...)  CLAUSE0 ...)]
    266                 [(eq? tb$stttg (car args))
    267                   STATE]
    268                 [else
    269                   (tb$errtstprcargs STATE args)]))))
     274              (cond [(null? args)
     275                      (tbm$define-test-body STATE DTOR ESCR TSTNAM
     276                        (INIT0 ...) (TERM0 ...)  CLAUSE0 ...)]
     277                    [(eq? tb$stttg (car args))
     278                      STATE]
     279                    [else
     280                      (tb$errtstprcargs STATE args)]))))
    270281        (tb$newtstprc 'define-test PRCVAR))] ) )
    271282
     
    443454;; this is the definition of the macro test-case:
    444455;; (test-case DESC DTOR-NAME ESCR-NAME EXPECTATIONS)
    445 ;; (test-case DESC DTOR-NAME ESCR-NAME (warn WARNING) EXPECTATIONS)
     456;; (test-case DESC DTOR-NAME ESCR-NAME (warn WRNG) EXPECTATIONS)
    446457;; (test-case DESC DTOR-NAME ESCR-NAME (FORMALS) EXPECTATIONS)
    447 ;; (test-case DESC DTOR-NAME ESCR-NAME (warn WARNING) (FORMALS) EXPECTATIONS)
     458;; (test-case DESC DTOR-NAME ESCR-NAME (warn WRNG) (FORMALS) EXPECTATIONS)
    448459;; DESC is an object (usually a string) that explains what the test-case is.
    449460;; DTOR-NAME is the name of the destructor object provided for you in the
     
    456467;;  calls. The first expectation that fails stops the evaluation in the test
    457468;;  case.
    458 ;; WARNING is a string (actually any type, but usually string) message that
     469;; WRNG is a string (actually any type, but usually string) message that
    459470;;  expains that something isn't quite right or there are special circumstances
    460471;;  to something.
     
    469480(define-syntax tbm$test-case-body
    470481  (syntax-rules ()
    471     [(_ STATE TSTNAM DTOR ESCR WARNING CLAUSE0 ...)
     482    [(_ STATE TSTNAM DTOR ESCR WRNG CLAUSE0 ...)
    472483      (let-syntax ([eval-expect
    473484                    (syntax-rules ()
     
    475486                        (lambda () (tbm$sieve-result STATE CLAUSE))])])
    476487        (let ([DTOR (tb$makdtr STATE)])
    477           (tb$tstcasbdy STATE TSTNAM DTOR WARNING
     488          (tb$tstcasbdy STATE TSTNAM DTOR WRNG
    478489            (lambda ()
    479490              ; Escaper will return here
     
    486497  (syntax-rules ()
    487498
    488     [(_ STATE TSTNAM DTOR ESCR WARNING () CLAUSE0 ...)
     499    [(_ STATE TSTNAM DTOR ESCR WRNG () CLAUSE0 ...)
    489500      (tbm$perform-test STATE 'case TSTNAM
    490         (tbm$test-case-body STATE TSTNAM DTOR ESCR WARNING CLAUSE0 ...))]
    491 
    492     [(_ STATE TSTNAM DTOR ESCR WARNING ([VAR VAL] ...) CLAUSE0 ...)
     501        (tbm$test-case-body STATE TSTNAM DTOR ESCR WRNG CLAUSE0 ...))]
     502
     503    [(_ STATE TSTNAM DTOR ESCR WRNG ([VAR VAL] ...) CLAUSE0 ...)
    493504      (tbm$perform-test STATE 'case TSTNAM
    494505        (let ([VAR (tbm$if-expr-eval STATE VAL)] ...)
    495           (tbm$test-case-body STATE TSTNAM DTOR ESCR WARNING CLAUSE0 ...)))]) )
     506          (tbm$test-case-body STATE TSTNAM DTOR ESCR WRNG CLAUSE0 ...)))]) )
    496507
    497508(define-syntax (test-case X)
    498509  (syntax-case X (warn)
    499510
    500     [(SK TSTNAM DTOR ESCR (warn WARNING) ([VAR VAL] ...) CLAUSE0 ...)
     511    [(SK TSTNAM DTOR ESCR (warn WRNG) ([VAR VAL] ...) CLAUSE0 ...)
    501512      (and (identifier? #'DTOR)
    502513           (identifier? #'ESCR)
    503514           (tbs$test-name? #'TSTNAM) )
    504515      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    505         #'(tbm$test-case-common STATE TSTNAM DTOR ESCR WARNING ([VAR VAL] ...) CLAUSE0 ...))]
     516        #'(tbm$test-case-common STATE TSTNAM DTOR ESCR WRNG ([VAR VAL] ...) CLAUSE0 ...))]
    506517
    507518    [(SK TSTNAM DTOR ESCR ([VAR VAL] ...) CLAUSE0 ...)
     
    512523        #'(tbm$test-case-common STATE TSTNAM DTOR ESCR '() ([VAR VAL] ...) CLAUSE0 ...))]
    513524
    514     [(SK TSTNAM DTOR ESCR (warn WARNING) CLAUSE0 ...)
     525    [(SK TSTNAM DTOR ESCR (warn WRNG) CLAUSE0 ...)
    515526      (and (identifier? #'DTOR)
    516527           (identifier? #'ESCR)
    517528           (tbs$test-name? #'TSTNAM) )
    518529      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    519         #'(tbm$test-case-common STATE TSTNAM DTOR ESCR WARNING () CLAUSE0 ...))]
     530        #'(tbm$test-case-common STATE TSTNAM DTOR ESCR WRNG () CLAUSE0 ...))]
    520531
    521532    [(SK TSTNAM DTOR ESCR CLAUSE0 ...)
     
    553564(define-syntax tbm$test-collect-body
    554565  (syntax-rules ()
    555     [(_ STATE TSTNAM DTOR ESCR CLTR CONT WARNING CLAUSE0 ...)
     566    [(_ STATE TSTNAM DTOR ESCR CLTR CONT WRNG CLAUSE0 ...)
    556567      (fluid-let-syntax (
    557568          [collect-test
     
    565576                  (set! CONT (tb$cltres STATE CLTR TSTNAM (tbm$sieve-result STATE RES))))])])
    566577        (let ([DTOR (tb$makdtr STATE)])
    567           (tb$tstcasbdy STATE TSTNAM DTOR WARNING
     578          (tb$tstcasbdy STATE TSTNAM DTOR WRNG
    568579            (lambda ()
    569580              ; Escaper will return here
     
    580591  (syntax-rules ()
    581592
    582     [(_ STATE TSTNAM DTOR ESCR WARNING () CLAUSE0 ...)
     593    [(_ STATE TSTNAM DTOR ESCR WRNG () CLAUSE0 ...)
    583594      (tbm$perform-test STATE 'case TSTNAM
    584595        (let ([collector
     
    588599                  results ) )]
    589600              [contflag #t])
    590           (tbm$test-collect-body STATE TSTNAM DTOR ESCR collector contflag WARNING CLAUSE0 ...)))]
    591 
    592     [(_ STATE TSTNAM DTOR ESCR WARNING ([VAR VAL] ...) CLAUSE0 ...)
     601          (tbm$test-collect-body STATE TSTNAM DTOR ESCR collector contflag WRNG CLAUSE0 ...)))]
     602
     603    [(_ STATE TSTNAM DTOR ESCR WRNG ([VAR VAL] ...) CLAUSE0 ...)
    593604      (tbm$perform-test STATE 'case TSTNAM
    594605        (let ([VAR (tbm$if-expr-eval STATE VAL)] ...)
     
    599610                    results ) )]
    600611              [contflag #t])
    601             (tbm$test-collect-body STATE TSTNAM DTOR ESCR collector contflag WARNING CLAUSE0 ...))))]) )
     612            (tbm$test-collect-body STATE TSTNAM DTOR ESCR collector contflag WRNG CLAUSE0 ...))))]) )
    602613
    603614(define-syntax (test-collect X)
    604615  (syntax-case X ()
    605616
    606     [(SK TSTNAM DTOR ESCR (warn WARNING) ([VAR VAL] ...) CLAUSE0 ...)
     617    [(SK TSTNAM DTOR ESCR (warn WRNG) ([VAR VAL] ...) CLAUSE0 ...)
    607618      (and (identifier? #'DTOR)
    608619           (identifier? #'ESCR)
    609620           (tbs$test-name? #'TSTNAM) )
    610621      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    611         #'(tbm$test-collect-common STATE TSTNAM DTOR ESCR WARNING ([VAR VAL] ...) CLAUSE0 ...))]
     622        #'(tbm$test-collect-common STATE TSTNAM DTOR ESCR WRNG ([VAR VAL] ...) CLAUSE0 ...))]
    612623
    613624    [(SK TSTNAM DTOR ESCR ([VAR VAL] ...) CLAUSE0 ...)
     
    618629        #'(tbm$test-collect-common STATE TSTNAM DTOR ESCR '() ([VAR VAL] ...) CLAUSE0 ...))]
    619630
    620     [(SK TSTNAM DTOR ESCR (warn WARNING) CLAUSE0 ...)
     631    [(SK TSTNAM DTOR ESCR (warn WRNG) CLAUSE0 ...)
    621632      (and (identifier? #'DTOR)
    622633           (identifier? #'ESCR)
    623634           (tbs$test-name? #'TSTNAM) )
    624635      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    625         #'(tbm$test-collect-common STATE TSTNAM DTOR ESCR WARNING () CLAUSE0 ...))]
     636        #'(tbm$test-collect-common STATE TSTNAM DTOR ESCR WRNG () CLAUSE0 ...))]
    626637
    627638    [(SK TSTNAM DTOR ESCR CLAUSE0 ...)
     
    652663;; this is the definition of the macro test-suite:
    653664;; (test-suite DESC DTOR-NAME ESCR-NAME TESTCASES|TESTSUITES|EXPECTATIONS)
    654 ;; (test-suite DESC DTOR-NAME ESCR-NAME (warn WARNING) TESTCASES|TESTSUITES|EXPECTATIONS)
     665;; (test-suite DESC DTOR-NAME ESCR-NAME (warn WRNG) TESTCASES|TESTSUITES|EXPECTATIONS)
    655666;; (test-suite DESC DTOR-NAME ESCR-NAME (FORMALS) TESTCASES|TESTSUITES|EXPECTATIONS)
    656 ;; (test-suite DESC DTOR-NAME ESCR-NAME (warn WARNING) (FORMALS) TESTCASES|TESTSUITES|EXPECTATIONS)
     667;; (test-suite DESC DTOR-NAME ESCR-NAME (warn WRNG) (FORMALS) TESTCASES|TESTSUITES|EXPECTATIONS)
    657668;; DESC is an object (usually a string) that explains what the test-case is.
    658669;; DTOR-NAME is the name of the destructor object provided for you in the
     
    667678;;  Usually expectations are not placed bare into packages. However they
    668679;;  can be, and the result tree walking code wil have to deal with it specially.
    669 ;; WARNING is a string (actually any type, but usually string) message that
     680;; WRNG is a string (actually any type, but usually string) message that
    670681;;  expains that something isn't quite right or there are special circumstances
    671682;;  to something.
     
    676687(define-syntax tbm$test-suite-body
    677688  (syntax-rules ()
    678     [(_ STATE TSTNAM DTOR ESCR WARNING CLAUSE0 ...)
     689    [(_ STATE TSTNAM DTOR ESCR WRNG CLAUSE0 ...)
    679690      (let ([DTOR (tb$makdtr STATE)])
    680         (tb$tstsutbdy STATE TSTNAM DTOR WARNING
     691        (tb$tstsutbdy STATE TSTNAM DTOR WRNG
    681692          (lambda ()
    682693            ; Escaper will return here
     
    689700  (syntax-rules ()
    690701
    691     [(_ STATE TSTNAM DTOR ESCR WARNING () CLAUSE0 ...)
     702    [(_ STATE TSTNAM DTOR ESCR WRNG () CLAUSE0 ...)
    692703      (tbm$perform-test STATE 'suite TSTNAM
    693         (tbm$test-suite-body STATE TSTNAM DTOR ESCR WARNING CLAUSE0 ...))]
    694 
    695     [(_ STATE TSTNAM DTOR ESCR WARNING ([VAR VAL] ...) CLAUSE0 ...)
     704        (tbm$test-suite-body STATE TSTNAM DTOR ESCR WRNG CLAUSE0 ...))]
     705
     706    [(_ STATE TSTNAM DTOR ESCR WRNG ([VAR VAL] ...) CLAUSE0 ...)
    696707      (tbm$perform-test STATE 'suite TSTNAM
    697708        (let ([VAR (tbm$if-expr-eval STATE VAL)] ...)
    698           (tbm$test-suite-body STATE TSTNAM DTOR ESCR WARNING CLAUSE0 ...)))]) )
     709          (tbm$test-suite-body STATE TSTNAM DTOR ESCR WRNG CLAUSE0 ...)))]) )
    699710
    700711(define-syntax (test-suite X)
    701712  (syntax-case X (warn)
    702713
    703     [(SK TSTNAM DTOR ESCR (warn WARNING) ([VAR VAL] ...) CLAUSE0 ...)
     714    [(SK TSTNAM DTOR ESCR (warn WRNG) ([VAR VAL] ...) CLAUSE0 ...)
    704715      (and (identifier? #'DTOR)
    705716           (identifier? #'ESCR)
    706717           (tbs$test-name? #'TSTNAM) )
    707718      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    708         #'(tbm$test-suite-common STATE TSTNAM DTOR ESCR WARNING ([VAR VAL] ...) CLAUSE0 ...))]
     719        #'(tbm$test-suite-common STATE TSTNAM DTOR ESCR WRNG ([VAR VAL] ...) CLAUSE0 ...))]
    709720
    710721    [(SK TSTNAM DTOR ESCR ([VAR VAL] ...) CLAUSE0 ...)
     
    715726        #'(tbm$test-suite-common STATE TSTNAM DTOR ESCR '() ([VAR VAL] ...) CLAUSE0 ...))]
    716727
    717     [(SK TSTNAM DTOR ESCR (warn WARNING) CLAUSE0 ...)
     728    [(SK TSTNAM DTOR ESCR (warn WRNG) CLAUSE0 ...)
    718729      (and (identifier? #'DTOR)
    719730           (identifier? #'ESCR)
    720731           (tbs$test-name? #'TSTNAM) )
    721732      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    722         #'(tbm$test-suite-common STATE TSTNAM DTOR ESCR WARNING () CLAUSE0 ...))]
     733        #'(tbm$test-suite-common STATE TSTNAM DTOR ESCR WRNG () CLAUSE0 ...))]
    723734
    724735    [(SK TSTNAM DTOR ESCR CLAUSE0 ...)
     
    756767    [(_ STATE CLAUSE0 ...)
    757768      (begin
    758         (if (tb$eval-mode? STATE)
    759           (begin CLAUSE0 ...))
     769        (when (tb$eval-mode? STATE)
     770          (begin CLAUSE0 ...) )
    760771        (tb$make-ignore-result STATE))] ) )
    761772
     
    775786;; the macro the user uses to create a destructor entity.
    776787;; (teardown MESSAGE clauses ...)
    777 ;; (teardown MESSAGE (warn WARNING) clauses ...)
     788;; (teardown MESSAGE (warn WRNG) clauses ...)
    778789;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    779790
     
    897908  (syntax-case X ()
    898909
    899     [(SK MSG)
     910    [(SK MESG)
    900911      (with-syntax ([STATE (tbs$state-synobj #'SK)]
    901912                    [ESCR (tbs$test-escr-synobj #'SK)])
    902         #'(tb$callescr STATE ESCR MSG #f))]
    903 
    904     [(SK MSG FINDING)
     913        #'(tb$callescr STATE ESCR MESG #f))]
     914
     915    [(SK MESG FINDING)
    905916      (boolean? (syntax-object->datum #'FINDING))
    906917      (with-syntax ([STATE (tbs$state-synobj #'SK)]
    907918                    [ESCR (tbs$test-escr-synobj #'SK)])
    908         #'(tb$callescr STATE ESCR MSG FINDING))]
    909 
    910     [(SK ESCR MSG)
    911       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    912         #'(tb$callescr STATE ESCR MSG #f))]
    913 
    914     [(SK ESCR MSG FINDING)
    915       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    916         #'(tb$callescr STATE ESCR MSG FINDING))] ) )
     919        #'(tb$callescr STATE ESCR MESG FINDING))]
     920
     921    [(SK ESCR MESG)
     922      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     923        #'(tb$callescr STATE ESCR MESG #f))]
     924
     925    [(SK ESCR MESG FINDING)
     926      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     927        #'(tb$callescr STATE ESCR MESG FINDING))] ) )
    917928
    918929;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    919930;; the macro the user uses to create the todo
    920931;; (todo MESSAGE)
    921 ;; (todo MESSAGE (warn WARNING))
     932;; (todo MESSAGE (warn WRNG))
    922933;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    923934
     
    925936  (syntax-case X (warn)
    926937
    927     [(SK MSG)
    928       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    929         #'(tb$make-todo-result STATE MSG '()))]
    930 
    931     [(SK MSG (warn WARNING))
    932       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    933         #'(tb$make-todo-result STATE MSG WARNING))] ) )
     938    [(SK MESG)
     939      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     940        #'(tb$make-todo-result STATE MESG '()))]
     941
     942    [(SK MESG (warn WRNG))
     943      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     944        #'(tb$make-todo-result STATE MESG WRNG))] ) )
    934945
    935946;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    936947;; the macro the user uses to create the gloss
    937948;; (gloss MESSAGE)
    938 ;; (gloss MESSAGE (warn WARNING))
     949;; (gloss MESSAGE (warn WRNG))
    939950;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    940951
     
    942953  (syntax-case X (warn)
    943954
    944     [(SK MSG)
    945       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    946         #'(tb$make-gloss-result STATE MSG '()))]
    947 
    948     [(SK MSG (warn WARNING))
    949       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    950         #'(tb$make-gloss-result STATE MSG WARNING))] ) )
     955    [(SK MESG)
     956      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     957        #'(tb$make-gloss-result STATE MESG '()))]
     958
     959    [(SK MESG (warn WRNG))
     960      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     961        #'(tb$make-gloss-result STATE MESG WRNG))] ) )
    951962
    952963;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    955966;; macro, i.e. ignored.
    956967;; (skip MESSAGE clauses ...)
    957 ;; (skip MESSAGE (warn WARNING) clauses ...)
     968;; (skip MESSAGE (warn WRNG) clauses ...)
    958969;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    959970
     
    961972  (syntax-case X (warn)
    962973
    963     [(SK MSG (warn WARNING) CLAUSE0 ...)
    964       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    965         #'(tb$make-skip-result STATE MSG WARNING))]
    966 
    967     [(SK MSG CLAUSE0 ...)
    968       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    969         #'(tb$make-skip-result STATE MSG '()))] ) )
     974    [(SK MESG (warn WRNG) CLAUSE0 ...)
     975      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     976        #'(tb$make-skip-result STATE MESG WRNG))]
     977
     978    [(SK MESG CLAUSE0 ...)
     979      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     980        #'(tb$make-skip-result STATE MESG '()))] ) )
    970981
    971982;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    10031014(define-syntax tbm$expect-unary
    10041015  (syntax-rules ()
    1005     [(_ STATE MSG WARNING KIND PRED EXPR)
    1006       (let ([message MSG])
     1016    [(_ STATE MESG WRNG KIND PRED EXPR)
     1017      (let ([message MESG])
    10071018        (tbm$perform-test STATE 'expect message
    1008           (tb$expt1 STATE message WARNING KIND PRED
     1019          (tb$expt1 STATE message WRNG KIND PRED
    10091020            'EXPR (tbm$try-expr STATE EXPR))))] ) )
    10101021
    10111022(define-syntax tbm$expect-binary
    10121023  (syntax-rules ()
    1013     [(_ STATE MSG WARNING KIND PRED EXPECTED EXPR)
    1014       (let ([message MSG])
     1024    [(_ STATE MESG WRNG KIND PRED EXPT EXPR)
     1025      (let ([message MESG])
    10151026        (tbm$perform-test STATE 'expect message
    1016           (tb$expt2 STATE message WARNING KIND PRED
    1017             EXPECTED 'EXPR (tbm$try-expr STATE EXPR))))] ) )
     1027          (tb$expt2 STATE message WRNG KIND PRED
     1028            EXPT 'EXPR (tbm$try-expr STATE EXPR))))] ) )
    10181029
    10191030(define-syntax tbm$expect-nary
    10201031  (syntax-rules ()
    1021     [(_ STATE MSG WARNING KIND EXPR UNEVALED)
    1022       (let ([message MSG])
     1032    [(_ STATE MESG WRNG KIND EXPR UNEVALED)
     1033      (let ([message MESG])
    10231034        (tbm$perform-test STATE 'expect message
    1024           (tb$expt1 STATE message WARNING KIND (cut tb$exptpred1 <> tb$true?)
     1035          (tb$expt1 STATE message WRNG KIND (cut tb$exptpred1 <> tb$true?)
    10251036            UNEVALED (tbm$try-expr STATE EXPR))))] ) )
    10261037
    10271038(define-syntax tbm$expect-near
    10281039  (syntax-rules ()
    1029     [(_ STATE MSG WARNING KIND TEST EXPECTED TOL EXPR)
    1030       (let ([message MSG])
     1040    [(_ STATE MESG WRNG KIND TEST EXPT TOL EXPR)
     1041      (let ([message MESG])
    10311042        (tbm$perform-test STATE 'expect message
    1032           (tb$exptnear STATE message WARNING KIND tb$exptpred2
    1033             EXPECTED TEST TOL 'EXPR (tbm$try-expr STATE EXPR))))] ) )
     1043          (tb$exptnear STATE message WRNG KIND tb$exptpred2
     1044            EXPT TEST TOL 'EXPR (tbm$try-expr STATE EXPR))))] ) )
    10341045
    10351046;;
     
    10371048(define-syntax tbm$expect-unary/values
    10381049  (syntax-rules ()
    1039     [(_ STATE MSG WARNING KIND PRED EXPR)
    1040       (let ([message MSG])
     1050    [(_ STATE MESG WRNG KIND PRED EXPR)
     1051      (let ([message MESG])
    10411052        (tbm$perform-test STATE 'expect message
    1042           (tb$expt1 STATE message WARNING KIND PRED
     1053          (tb$expt1 STATE message WRNG KIND PRED
    10431054            'EXPR (tbm$try-expr STATE (receive EXPR)))))] ) )
    10441055
    10451056(define-syntax tbm$expect-binary/values
    10461057  (syntax-rules ()
    1047     [(_ STATE MSG WARNING KIND PRED EXPECTED EXPR)
    1048       (let ([message MSG])
     1058    [(_ STATE MESG WRNG KIND PRED EXPT EXPR)
     1059      (let ([message MESG])
    10491060        (tbm$perform-test STATE 'expect message
    1050           (tb$expt2 STATE message WARNING KIND PRED
    1051             (receive EXPECTED) 'EXPR (tbm$try-expr STATE (receive EXPR)))))] ) )
     1061          (tb$expt2 STATE message WRNG KIND PRED
     1062            (receive EXPT) 'EXPR (tbm$try-expr STATE (receive EXPR)))))] ) )
    10521063
    10531064(define-syntax tbm$expect-near/values
    10541065  (syntax-rules ()
    1055     [(_ STATE MSG WARNING KIND TEST EXPECTED TOL EXPR)
    1056       (let ([message MSG])
     1066    [(_ STATE MESG WRNG KIND TEST EXPT TOL EXPR)
     1067      (let ([message MESG])
    10571068        (tbm$perform-test STATE 'expect message
    1058           (tb$exptnear STATE message WARNING KIND tb$exptvalspred2
    1059             (receive EXPECTED) TEST TOL 'EXPR (tbm$try-expr STATE (receive EXPR)))))] ) )
     1069          (tb$exptnear STATE message WRNG KIND tb$exptvalspred2
     1070            (receive EXPT) TEST TOL 'EXPR (tbm$try-expr STATE (receive EXPR)))))] ) )
    10601071
    10611072;;
     
    10631074(define-syntax tbm$expect-ec
    10641075  (syntax-rules ()
    1065     [(_ STATE MSG WARNING KIND PRED EC-OPER EC-EXPR EC-ARG0 ...)
    1066       (let ([message MSG])
     1076    [(_ STATE MESG WRNG KIND PRED EC-OPER EC-EXPR EC-ARG0 ...)
     1077      (let ([message MESG])
    10671078        (tbm$perform-test STATE 'expect message
    1068           (tb$expt1 STATE message WARNING KIND PRED
     1079          (tb$expt1 STATE message WRNG KIND PRED
    10691080            'EC-EXPR
    10701081            (tbm$try-expr STATE (EC-OPER EC-ARG0 ... EC-EXPR)))))] ) )
     
    10741085(define-syntax tbm$expect-exception
    10751086  (syntax-rules ()
    1076     [(_ STATE MSG WARNING KIND PATT EXPR)
    1077       (let ([message MSG])
     1087    [(_ STATE MESG WRNG KIND PATT EXPR)
     1088      (let ([message MESG])
    10781089        (tbm$perform-test STATE 'expect message
    1079           (tb$exptexn STATE message WARNING KIND
     1090          (tb$exptexn STATE message WRNG KIND
    10801091            (lambda (exn) (tbm$excp-test exn PATT))
    10811092            'PATT 'EXPR (tbm$try-excp-expr STATE EXPR))))] ) )
     
    11411152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    11421153
    1143 ;; Returns the 'expect-' suffix symbol from a predicate symbol
    1144 
    1145 (define-for-syntax (tbs$suffsym-synobj sk pred)
    1146   (let* ([str (tbs$conc pred)]
    1147          [end (sub1 (string-length str))])
    1148     (tbs$conc->sym-synobj sk
    1149       (if (char=? #\? (string-ref str end))
    1150         (substring str 0 end)
    1151         str)) ) )
    1152 
    1153 ;; Returns the unary or binary kind string from a suffix symbol
    1154 
    1155 (define-for-syntax (tbs$kndstr1-synobj sk suff)
    1156   (tbs$conc->str-synobj sk suff) )
     1154;; Returns the binary kind string from a suffix symbol
    11571155
    11581156(define-for-syntax (tbs$kndstr2-synobj sk suff)
    1159   (let ([str-synobj (tbs$kndstr1-synobj sk suff)])
     1157  (let ([str-synobj (tbs$conc->str-synobj sk suff)])
    11601158    (if (substring-index "/values" (tbs$conc str-synobj))
    1161       str-synobj
    1162       (tbs$conc->str-synobj sk str-synobj "/values")) ) )
    1163 
    1164 ;; Returns the unary or binary expect name string from a suffix symbol
    1165 
    1166 (define-for-syntax (tbs$expctsym1-synobj sk suff)
    1167   (tbs$conc->sym-synobj sk "expect-" suff) )
     1159        str-synobj
     1160        (tbs$conc->str-synobj sk str-synobj "/values") ) ) )
     1161
     1162;; Returns the binary expect name string from a suffix symbol
    11681163
    11691164(define-for-syntax (tbs$expctsym2-synobj sk suff)
    1170   (let ([sym-synobj (tbs$expctsym1-synobj sk suff)])
     1165  (let ([sym-synobj (tbs$conc->sym-synobj sk "expect-" suff)])
    11711166    (if (substring-index "/values" (tbs$conc sym-synobj))
    1172       sym-synobj
    1173       (tbs$conc->sym-synobj sk sym-synobj "/values")) ) )
     1167        sym-synobj
     1168        (tbs$conc->sym-synobj sk sym-synobj "/values") ) ) )
    11741169
    11751170;;
     
    11861181                #f '() KIND (cut tb$exptpred1 <> PRED) EXPR))]
    11871182
    1188           [(SK (warn WARNING) EXPR)
     1183          [(SK (warn WRNG) EXPR)
    11891184            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    11901185              #'(tbm$expect-unary STATE
    1191                 #f WARNING KIND (cut tb$exptpred1 <> PRED) EXPR))]
    1192 
    1193           [(SK MSG EXPR)
     1186                #f WRNG KIND (cut tb$exptpred1 <> PRED) EXPR))]
     1187
     1188          [(SK MESG EXPR)
    11941189            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    11951190              #'(tbm$expect-unary STATE
    1196                 MSG '() KIND (cut tb$exptpred1 <> PRED) EXPR))]
    1197 
    1198           [(SK MSG (warn WARNING) EXPR)
     1191                MESG '() KIND (cut tb$exptpred1 <> PRED) EXPR))]
     1192
     1193          [(SK MESG (warn WRNG) EXPR)
    11991194            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12001195              #'(tbm$expect-unary STATE
    1201                 MSG WARNING KIND (cut tb$exptpred1 <> PRED) EXPR))]))] ) )
     1196                MESG WRNG KIND (cut tb$exptpred1 <> PRED) EXPR))]))] ) )
    12021197
    12031198(define-syntax tbm$define-expect-binary-common
     
    12071202        (syntax-case X (warn)
    12081203
    1209           [(SK EXPECTED EXPR)
     1204          [(SK EXPT EXPR)
    12101205            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12111206              #'(tbm$expect-binary STATE
    1212                 #f '() KIND (cut tb$exptpred2 <> <> PRED) EXPECTED EXPR))]
    1213 
    1214           [(SK (warn WARNING) EXPECTED EXPR)
     1207                #f '() KIND (cut tb$exptpred2 <> <> PRED) EXPT EXPR))]
     1208
     1209          [(SK (warn WRNG) EXPT EXPR)
    12151210            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12161211              #'(tbm$expect-binary STATE
    1217                 #f WARNING KIND (cut tb$exptpred2 <> <> PRED) EXPECTED EXPR))]
    1218 
    1219           [(SK MSG EXPECTED EXPR)
     1212                #f WRNG KIND (cut tb$exptpred2 <> <> PRED) EXPT EXPR))]
     1213
     1214          [(SK MESG EXPT EXPR)
    12201215            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12211216              #'(tbm$expect-binary STATE
    1222                 MSG '() KIND (cut tb$exptpred2 <> <> PRED) EXPECTED EXPR))]
    1223 
    1224           [(SK MSG (warn WARNING) EXPECTED EXPR)
     1217                MESG '() KIND (cut tb$exptpred2 <> <> PRED) EXPT EXPR))]
     1218
     1219          [(SK MESG (warn WRNG) EXPT EXPR)
    12251220            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12261221              #'(tbm$expect-binary STATE
    1227                 MSG WARNING KIND (cut tb$exptpred2 <> <> PRED) EXPECTED EXPR))]))] ) )
     1222                MESG WRNG KIND (cut tb$exptpred2 <> <> PRED) EXPT EXPR))]))] ) )
    12281223
    12291224(define-syntax tbm$define-expect-unary/values-common
     
    12381233                #f '() KIND (cut tb$exptvalspred1 <> PRED) EXPR))]
    12391234
    1240           [(SK (warn WARNING) EXPR)
     1235          [(SK (warn WRNG) EXPR)
    12411236            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12421237              #'(tbm$expect-unary/values STATE
    1243                 #f WARNING KIND (cut tb$exptvalspred1 <> PRED) EXPR))]
    1244 
    1245           [(SK MSG EXPR)
     1238                #f WRNG KIND (cut tb$exptvalspred1 <> PRED) EXPR))]
     1239
     1240          [(SK MESG EXPR)
    12461241            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12471242              #'(tbm$expect-unary/values STATE
    1248                 MSG '() KIND (cut tb$exptvalspred1 <> PRED) EXPR))]
    1249 
    1250           [(SK MSG (warn WARNING) EXPR)
     1243                MESG '() KIND (cut tb$exptvalspred1 <> PRED) EXPR))]
     1244
     1245          [(SK MESG (warn WRNG) EXPR)
    12511246            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12521247              #'(tbm$expect-unary/values STATE
    1253                 MSG WARNING KIND (cut tb$exptvalspred1 <> PRED) EXPR))]))] ) )
     1248                MESG WRNG KIND (cut tb$exptvalspred1 <> PRED) EXPR))]))] ) )
    12541249
    12551250(define-syntax tbm$define-expect-binary/values-common
     
    12591254        (syntax-case X (warn)
    12601255
    1261           [(SK EXPECTED EXPR)
     1256          [(SK EXPT EXPR)
    12621257            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12631258              #'(tbm$expect-binary/values STATE
    1264                 #f '() KIND (cut tb$exptvalspred2 <> <> PRED) EXPECTED EXPR))]
    1265 
    1266           [(SK (warn WARNING) EXPECTED EXPR)
     1259                #f '() KIND (cut tb$exptvalspred2 <> <> PRED) EXPT EXPR))]
     1260
     1261          [(SK (warn WRNG) EXPT EXPR)
    12671262            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12681263              #'(tbm$expect-binary/values STATE
    1269                 #f WARNING KIND (cut tb$exptvalspred2 <> <> PRED) EXPECTED EXPR))]
    1270 
    1271           [(SK MSG EXPECTED EXPR)
     1264                #f WRNG KIND (cut tb$exptvalspred2 <> <> PRED) EXPT EXPR))]
     1265
     1266          [(SK MESG EXPT EXPR)
    12721267            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12731268              #'(tbm$expect-binary/values STATE
    1274                 MSG '() KIND (cut tb$exptvalspred2 <> <> PRED) EXPECTED EXPR))]
    1275 
    1276           [(SK MSG (warn WARNING) EXPECTED EXPR)
     1269                MESG '() KIND (cut tb$exptvalspred2 <> <> PRED) EXPT EXPR))]
     1270
     1271          [(SK MESG (warn WRNG) EXPT EXPR)
    12771272            (with-syntax ([STATE (tbs$state-synobj #'SK)])
    12781273              #'(tbm$expect-binary/values STATE
    1279                 MSG WARNING KIND (cut tb$exptvalspred2 <> <> PRED) EXPECTED EXPR))]))] ) )
     1274                MESG WRNG KIND (cut tb$exptvalspred2 <> <> PRED) EXPT EXPR))]))] ) )
    12801275
    12811276;; Public
     
    12871282      (identifier? #'PRED)
    12881283      (with-syntax ([SUFF (tbs$suffsym-synobj #'ESK #'PRED)])
    1289         (with-syntax ([NAME (tbs$expctsym1-synobj #'ESK #'SUFF)]
    1290                       [KIND (tbs$kndstr1-synobj #'ESK #'SUFF)])
     1284        (with-syntax ([NAME (tbs$conc->sym-synobj #'ESK "expect-" #'SUFF)]
     1285                      [KIND (tbs$conc->str-synobj #'ESK #'SUFF)])
    12911286          #'(tbm$define-expect-unary-common NAME PRED SUFF KIND)))]
    12921287
     
    12941289      (and (identifier? #'PRED)
    12951290           (identifier? #'SUFF))
    1296       (with-syntax ([NAME (tbs$expctsym1-synobj #'ESK #'SUFF)]
    1297                     [KIND (tbs$kndstr1-synobj #'ESK #'SUFF)])
     1291      (with-syntax ([NAME (tbs$conc->sym-synobj #'ESK "expect-" #'SUFF)]
     1292                    [KIND (tbs$conc->str-synobj #'ESK #'SUFF)])
    12981293        #'(tbm$define-expect-unary-common NAME PRED SUFF KIND))]
    12991294
     
    13021297           (identifier? #'SUFF)
    13031298           (string? (syntax-object->datum #'KIND)))
    1304       (with-syntax ([NAME (tbs$expctsym1-synobj #'ESK #'SUFF)])
     1299      (with-syntax ([NAME (tbs$conc->sym-synobj #'ESK "expect-" #'SUFF)])
    13051300        #'(tbm$define-expect-unary-common NAME PRED SUFF KIND))] ) )
    13061301
     
    13111306      (identifier? #'PRED)
    13121307      (with-syntax ([SUFF (tbs$suffsym-synobj #'ESK #'PRED)])
    1313         (with-syntax ([NAME (tbs$expctsym1-synobj #'ESK #'SUFF)]
    1314                       [KIND (tbs$kndstr1-synobj #'ESK #'SUFF)])
     1308        (with-syntax ([NAME (tbs$conc->sym-synobj #'ESK "expect-" #'SUFF)]
     1309                      [KIND (tbs$conc->str-synobj #'ESK #'SUFF)])
    13151310          #'(tbm$define-expect-binary-common NAME PRED SUFF KIND)))]
    13161311
     
    13181313      (and (identifier? #'PRED)
    13191314           (identifier? #'SUFF))
    1320       (with-syntax ([NAME (tbs$expctsym1-synobj #'ESK #'SUFF)]
    1321                     [KIND (tbs$kndstr1-synobj #'ESK #'SUFF)])
     1315      (with-syntax ([NAME (tbs$conc->sym-synobj #'ESK "expect-" #'SUFF)]
     1316                    [KIND (tbs$conc->str-synobj #'ESK #'SUFF)])
    13221317        #'(tbm$define-expect-binary-common NAME PRED SUFF KIND))]
    13231318
     
    13261321           (identifier? #'SUFF)
    13271322           (string? (syntax-object->datum #'KIND)))
    1328       (with-syntax ([NAME (tbs$expctsym1-synobj #'ESK #'SUFF)])
     1323      (with-syntax ([NAME (tbs$conc->sym-synobj #'ESK "expect-" #'SUFF)])
    13291324        #'(tbm$define-expect-binary-common NAME PRED SUFF KIND))] ) )
    13301325
     
    13891384            (define-syntax (EXPT X)
    13901385              (syntax-case X (warn)
    1391                 [(SK (warn WARNING) ARG0 ...)
     1386                [(SK (warn WRNG) ARG0 ...)
    13921387                  (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1393                     #'(tbm$expect-nary STATE #f WARNING KIND
     1388                    #'(tbm$expect-nary STATE #f WRNG KIND
    13941389                        (PRED ARG0 ...) '(? ARG0 ...)))]
    1395                 [(SK MSG (warn WARNING) ARG0 ...)
     1390                [(SK MESG (warn WRNG) ARG0 ...)
    13961391                  (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1397                     #'(tbm$expect-nary STATE MSG WARNING KIND
     1392                    #'(tbm$expect-nary STATE MESG WRNG KIND
    13981393                        (PRED ARG0 ...) '(? ARG0 ...)))]
    1399                 [(SK MSG ARG0 ...)
     1394                [(SK MESG ARG0 ...)
    14001395                  (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1401                     #'(tbm$expect-nary STATE MSG '() KIND
     1396                    #'(tbm$expect-nary STATE MESG '() KIND
    14021397                        (PRED ARG0 ...) '(? ARG0 ...)))]) ) ) )] ) )
    14031398
     
    14081403(define-syntax tbm$expect-unary-common
    14091404  (syntax-rules ()
    1410     [(_ STATE MSG WARNING KIND PRED EXPR)
    1411       (tbm$expect-unary STATE MSG WARNING
     1405    [(_ STATE MESG WRNG KIND PRED EXPR)
     1406      (tbm$expect-unary STATE MESG WRNG
    14121407        KIND (cut tb$exptpred1 <> PRED) EXPR)] ) )
    14131408
     
    14151410  (syntax-case X (warn)
    14161411
    1417     [(SK (warn WARNING) KIND PRED EXPR)
    1418       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1419         #'(tbm$expect-unary-common STATE #f WARNING KIND PRED EXPR))]
     1412    [(SK (warn WRNG) KIND PRED EXPR)
     1413      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1414        #'(tbm$expect-unary-common STATE #f WRNG KIND PRED EXPR))]
    14201415
    14211416    [(SK KIND PRED EXPR)
     
    14231418        #'(tbm$expect-unary-common STATE #f '() KIND PRED EXPR))]
    14241419
    1425     [(SK MSG KIND PRED EXPR)
    1426       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1427         #'(tbm$expect-unary-common STATE MSG '() KIND PRED EXPR))]
    1428 
    1429     [(SK MSG (warn WARNING) KIND PRED EXPR)
    1430       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1431         #'(tbm$expect-unary-common STATE MSG WARNING KIND PRED EXPR))] ) )
     1420    [(SK MESG KIND PRED EXPR)
     1421      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1422        #'(tbm$expect-unary-common STATE MESG '() KIND PRED EXPR))]
     1423
     1424    [(SK MESG (warn WRNG) KIND PRED EXPR)
     1425      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1426        #'(tbm$expect-unary-common STATE MESG WRNG KIND PRED EXPR))] ) )
    14321427
    14331428;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    14371432(define-syntax tbm$expect-binary-common
    14381433  (syntax-rules ()
    1439     [(_ STATE MSG WARNING KIND PRED EXPECTED EXPR)
     1434    [(_ STATE MESG WRNG KIND PRED EXPT EXPR)
    14401435      (tbm$expect-binary STATE
    1441         MSG WARNING
    1442         KIND (cut tb$exptpred2 <> <> PRED) EXPECTED EXPR)] ) )
     1436        MESG WRNG
     1437        KIND (cut tb$exptpred2 <> <> PRED) EXPT EXPR)] ) )
    14431438
    14441439(define-syntax (expect-binary X)
    14451440  (syntax-case X (warn)
    14461441
    1447     [(SK (warn WARNING) KIND PRED EXPECTED EXPR)
    1448       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1449         #'(tbm$expect-binary-common STATE #f WARNING KIND PRED EXPECTED EXPR))]
    1450 
    1451     [(SK KIND PRED EXPECTED EXPR)
    1452       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1453         #'(tbm$expect-binary-common STATE #f '() KIND PRED EXPECTED EXPR))]
    1454 
    1455     [(SK MSG KIND PRED EXPECTED EXPR)
    1456       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1457         #'(tbm$expect-binary-common STATE MSG '() KIND PRED EXPECTED EXPR))]
    1458 
    1459     [(SK MSG (warn WARNING) KIND PRED EXPECTED EXPR)
    1460       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1461         #'(tbm$expect-binary-common STATE MSG WARNING KIND PRED EXPECTED EXPR))] ) )
     1442    [(SK (warn WRNG) KIND PRED EXPT EXPR)
     1443      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1444        #'(tbm$expect-binary-common STATE #f WRNG KIND PRED EXPT EXPR))]
     1445
     1446    [(SK KIND PRED EXPT EXPR)
     1447      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1448        #'(tbm$expect-binary-common STATE #f '() KIND PRED EXPT EXPR))]
     1449
     1450    [(SK MESG KIND PRED EXPT EXPR)
     1451      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1452        #'(tbm$expect-binary-common STATE MESG '() KIND PRED EXPT EXPR))]
     1453
     1454    [(SK MESG (warn WRNG) KIND PRED EXPT EXPR)
     1455      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1456        #'(tbm$expect-binary-common STATE MESG WRNG KIND PRED EXPT EXPR))] ) )
    14621457
    14631458;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    14671462(define-syntax tbm$expect-success-common
    14681463  (syntax-rules ()
    1469     [(_ STATE MSG WARNING EXPR)
    1470       (tbm$expect-unary STATE MSG WARNING "success" tb$exptsucc EXPR)] ) )
     1464    [(_ STATE MESG WRNG EXPR)
     1465      (tbm$expect-unary STATE MESG WRNG "success" tb$exptsucc EXPR)] ) )
    14711466
    14721467(define-syntax (expect-success X)
     
    14771472        #'(tbm$expect-success-common STATE #f '() EXPR))]
    14781473
    1479     [(SK (warn WARNING) EXPR)
     1474    [(SK (warn WRNG) EXPR)
    14801475       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1481         #'(tbm$expect-success-common STATE #f WARNING EXPR))]
    1482 
    1483     [(SK MSG EXPR)
    1484       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1485         #'(tbm$expect-success-common STATE MSG '() EXPR))]
    1486 
    1487     [(SK MSG (warn WARNING) EXPR)
    1488       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1489         #'(tbm$expect-success-common STATE MSG WARNING EXPR))] ) )
     1476        #'(tbm$expect-success-common STATE #f WRNG EXPR))]
     1477
     1478    [(SK MESG EXPR)
     1479      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1480        #'(tbm$expect-success-common STATE MESG '() EXPR))]
     1481
     1482    [(SK MESG (warn WRNG) EXPR)
     1483      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1484        #'(tbm$expect-success-common STATE MESG WRNG EXPR))] ) )
    14901485
    14911486;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    14951490(define-syntax tbm$expect-failure-common
    14961491  (syntax-rules ()
    1497     [(_ STATE MSG WARNING EXPR)
    1498       (tbm$expect-unary STATE MSG WARNING "failure" tb$exptfail EXPR)] ) )
     1492    [(_ STATE MESG WRNG EXPR)
     1493      (tbm$expect-unary STATE MESG WRNG "failure" tb$exptfail EXPR)] ) )
    14991494
    15001495(define-syntax (expect-failure X)
     
    15051500        #'(tbm$expect-failure-common STATE #f '() EXPR))]
    15061501
    1507     [(SK (warn WARNING) EXPR)
     1502    [(SK (warn WRNG) EXPR)
    15081503       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1509         #'(tbm$expect-failure-common STATE #f WARNING EXPR))]
    1510 
    1511     [(SK MSG EXPR)
    1512       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1513         #'(tbm$expect-failure-common STATE MSG '() EXPR))]
    1514 
    1515     [(SK MSG (warn WARNING) EXPR)
    1516       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1517         #'(tbm$expect-failure-common STATE MSG WARNING EXPR))] ) )
     1504        #'(tbm$expect-failure-common STATE #f WRNG EXPR))]
     1505
     1506    [(SK MESG EXPR)
     1507      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1508        #'(tbm$expect-failure-common STATE MESG '() EXPR))]
     1509
     1510    [(SK MESG (warn WRNG) EXPR)
     1511      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1512        #'(tbm$expect-failure-common STATE MESG WRNG EXPR))] ) )
    15181513
    15191514;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    15241519  (syntax-rules ()
    15251520
    1526     [(_ STATE MSG WARNING EXPECTED EXPR)
    1527       (tbm$expect-near-common STATE MSG WARNING
    1528         EXPECTED (tb$state-tolerance STATE) EXPR)]
    1529 
    1530     [(_ STATE MSG WARNING EXPECTED TOL EXPR)
    1531       (tbm$expect-near STATE MSG WARNING
    1532         "near" tb$near? EXPECTED TOL EXPR)] ) )
     1521    [(_ STATE MESG WRNG EXPT EXPR)
     1522      (tbm$expect-near-common STATE MESG WRNG
     1523        EXPT (tb$state-tolerance STATE) EXPR)]
     1524
     1525    [(_ STATE MESG WRNG EXPT TOL EXPR)
     1526      (tbm$expect-near STATE MESG WRNG
     1527        "near" tb$near? EXPT TOL EXPR)] ) )
    15331528
    15341529(define-syntax (expect-near X)
    15351530  (syntax-case X (warn)
    15361531
    1537     [(SK EXPECTED EXPR)
    1538       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1539         #'(tbm$expect-near-common STATE #f '() EXPECTED EXPR))]
    1540 
    1541     [(SK (warn WARNING) EXPECTED EXPR)
    1542       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1543         #'(tbm$expect-near-common STATE #f WARNING EXPECTED EXPR))]
    1544 
    1545     [(SK MSG EXPECTED EXPR)
    1546       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1547         #'(tbm$expect-near-common STATE MSG '() EXPECTED EXPR))]
    1548 
    1549     ;;[(SK EXPECTED TOL EXPR) Cannot catch w/o much todo]
    1550 
    1551     [(SK (warn WARNING) EXPECTED TOL EXPR)
    1552       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1553         #'(tbm$expect-near-common STATE #f WARNING EXPECTED TOL EXPR))]
    1554 
    1555     [(SK MSG (warn WARNING) EXPECTED EXPR)
    1556       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1557         #'(tbm$expect-near-common STATE MSG WARNING EXPECTED EXPR))]
    1558 
    1559     [(SK MSG EXPECTED TOL EXPR)
    1560       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1561         #'(tbm$expect-near-common STATE MSG '() EXPECTED TOL EXPR))]
    1562 
    1563     [(SK MSG (warn WARNING) EXPECTED TOL EXPR)
    1564       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1565         #'(tbm$expect-near-common STATE MSG WARNING EXPECTED TOL EXPR))] ) )
     1532    [(SK EXPT EXPR)
     1533      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1534        #'(tbm$expect-near-common STATE #f '() EXPT EXPR))]
     1535
     1536    [(SK (warn WRNG) EXPT EXPR)
     1537      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1538        #'(tbm$expect-near-common STATE #f WRNG EXPT EXPR))]
     1539
     1540    [(SK MESG EXPT EXPR)
     1541      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1542        #'(tbm$expect-near-common STATE MESG '() EXPT EXPR))]
     1543
     1544    ;;[(SK EXPT TOL EXPR) Cannot catch w/o much todo]
     1545
     1546    [(SK (warn WRNG) EXPT TOL EXPR)
     1547      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1548        #'(tbm$expect-near-common STATE #f WRNG EXPT TOL EXPR))]
     1549
     1550    [(SK MESG (warn WRNG) EXPT EXPR)
     1551      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1552        #'(tbm$expect-near-common STATE MESG WRNG EXPT EXPR))]
     1553
     1554    [(SK MESG EXPT TOL EXPR)
     1555      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1556        #'(tbm$expect-near-common STATE MESG '() EXPT TOL EXPR))]
     1557
     1558    [(SK MESG (warn WRNG) EXPT TOL EXPR)
     1559      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1560        #'(tbm$expect-near-common STATE MESG WRNG EXPT TOL EXPR))] ) )
    15661561
    15671562;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    15711566(define-syntax tbm$expect-unary/values-common
    15721567  (syntax-rules ()
    1573     [(_ STATE MSG WARNING KIND (PRED0 PRED1 ...) EXPR)
     1568    [(_ STATE MESG WRNG KIND (PRED0 PRED1 ...) EXPR)
    15741569      (tbm$expect-unary/values STATE
    1575         MSG WARNING KIND
     1570        MESG WRNG KIND
    15761571        (tb$makmltprd1 (list PRED0 PRED1 ...)) EXPR)] ) )
    15771572
     
    15841579            (PRED0 PRED1 ...) EXPR))]
    15851580
    1586     [(SK (warn WARNING) KIND (PRED0 PRED1 ...) EXPR)
     1581    [(SK (warn WRNG) KIND (PRED0 PRED1 ...) EXPR)
    15871582      (with-syntax ([STATE (datum->syntax-object #'SK 'tb$stt)])
    1588         #'(tbm$expect-unary/values-common STATE #f WARNING KIND
     1583        #'(tbm$expect-unary/values-common STATE #f WRNG KIND
    15891584            (PRED0 PRED1 ...) EXPR))]
    15901585
    1591     [(SK MSG KIND (PRED0 PRED1 ...) EXPR)
     1586    [(SK MESG KIND (PRED0 PRED1 ...) EXPR)
    15921587      (with-syntax ([STATE (datum->syntax-object #'SK 'tb$stt)])
    1593         #'(tbm$expect-unary/values-common STATE MSG '() KIND
     1588        #'(tbm$expect-unary/values-common STATE MESG '() KIND
    15941589            (PRED0 PRED1 ...) EXPR))]
    15951590
    1596     [(SK MSG (warn WARNING) KIND (PRED0 PRED1 ...) EXPR)
     1591    [(SK MESG (warn WRNG) KIND (PRED0 PRED1 ...) EXPR)
    15971592      (with-syntax ([STATE (datum->syntax-object #'SK 'tb$stt)])
    1598         #'(tbm$expect-unary/values-common STATE MSG WARNING KIND
     1593        #'(tbm$expect-unary/values-common STATE MESG WRNG KIND
    15991594            (PRED0 PRED1 ...) EXPR))] ) )
    16001595
     
    16051600(define-syntax tbm$expect-binary/values-common
    16061601  (syntax-rules ()
    1607     [(_ STATE MSG WARNING KIND (PRED0 PRED1 ...) EXPECTED EXPR)
     1602    [(_ STATE MESG WRNG KIND (PRED0 PRED1 ...) EXPT EXPR)
    16081603      (tbm$expect-binary/values STATE
    1609         MSG WARNING KIND
    1610         (tb$makmltprd2 (list PRED0 PRED1 ...)) EXPECTED EXPR)] ) )
     1604        MESG WRNG KIND
     1605        (tb$makmltprd2 (list PRED0 PRED1 ...)) EXPT EXPR)] ) )
    16111606
    16121607(define-syntax (expect-binary/values X)
    16131608  (syntax-case X (warn)
    16141609
    1615     [(SK KIND (PRED0 PRED1 ...) EXPECTED EXPR)
     1610    [(SK KIND (PRED0 PRED1 ...) EXPT EXPR)
    16161611      (with-syntax ([STATE (datum->syntax-object #'SK 'tb$stt)])
    16171612        #'(tbm$expect-binary/values-common STATE #f '() KIND
    1618             (PRED0 PRED1 ...) EXPECTED EXPR))]
    1619 
    1620     [(SK (warn WARNING) KIND (PRED0 PRED1 ...) EXPECTED EXPR)
     1613            (PRED0 PRED1 ...) EXPT EXPR))]
     1614
     1615    [(SK (warn WRNG) KIND (PRED0 PRED1 ...) EXPT EXPR)
    16211616      (with-syntax ([STATE (datum->syntax-object #'SK 'tb$stt)])
    1622         #'(tbm$expect-binary/values-common STATE #f WARNING KIND
    1623             (PRED0 PRED1 ...) EXPECTED EXPR))]
    1624 
    1625     [(SK MSG KIND (PRED0 PRED1 ...) EXPECTED EXPR)
     1617        #'(tbm$expect-binary/values-common STATE #f WRNG KIND
     1618            (PRED0 PRED1 ...) EXPT EXPR))]
     1619
     1620    [(SK MESG KIND (PRED0 PRED1 ...) EXPT EXPR)
    16261621      (with-syntax ([STATE (datum->syntax-object #'SK 'tb$stt)])
    1627         #'(tbm$expect-binary/values-common STATE MSG '() KIND
    1628             (PRED0 PRED1 ...) EXPECTED EXPR))]
    1629 
    1630     [(SK MSG (warn WARNING) KIND (PRED0 PRED1 ...) EXPECTED EXPR)
     1622        #'(tbm$expect-binary/values-common STATE MESG '() KIND
     1623            (PRED0 PRED1 ...) EXPT EXPR))]
     1624
     1625    [(SK MESG (warn WRNG) KIND (PRED0 PRED1 ...) EXPT EXPR)
    16311626      (with-syntax ([STATE (datum->syntax-object #'SK 'tb$stt)])
    1632         #'(tbm$expect-binary/values-common STATE MSG WARNING KIND
    1633             (PRED0 PRED1 ...) EXPECTED EXPR))] ) )
     1627        #'(tbm$expect-binary/values-common STATE MESG WRNG KIND
     1628            (PRED0 PRED1 ...) EXPT EXPR))] ) )
    16341629
    16351630;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    16401635  (syntax-rules ()
    16411636
    1642     [(_ STATE MSG WARNING EXPECTED EXPR)
    1643       (tbm$expect-near/values-common STATE MSG WARNING
    1644         EXPECTED (tb$state-tolerance STATE) EXPR)]
    1645 
    1646     [(_ STATE MSG WARNING EXPECTED TOL EXPR)
    1647       (tbm$expect-near/values STATE MSG WARNING
    1648         "near/values" tb$near? EXPECTED TOL EXPR)] ) )
     1637    [(_ STATE MESG WRNG EXPT EXPR)
     1638      (tbm$expect-near/values-common STATE MESG WRNG
     1639        EXPT (tb$state-tolerance STATE) EXPR)]
     1640
     1641    [(_ STATE MESG WRNG EXPT TOL EXPR)
     1642      (tbm$expect-near/values STATE MESG WRNG
     1643        "near/values" tb$near? EXPT TOL EXPR)] ) )
    16491644
    16501645(define-syntax (expect-near/values X)
    16511646  (syntax-case X (warn)
    16521647
    1653     [(SK EXPECTED EXPR)
    1654       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1655         #'(tbm$expect-near/values-common STATE #f '() EXPECTED EXPR))]
    1656 
    1657     [(SK (warn WARNING) EXPECTED EXPR)
    1658       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1659         #'(tbm$expect-near/values-common STATE #f WARNING EXPECTED EXPR))]
    1660 
    1661     [(SK MSG EXPECTED EXPR)
    1662       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1663         #'(tbm$expect-near/values-common STATE MSG '() EXPECTED EXPR))]
    1664 
    1665     ;;[(SK EXPECTED TOL EXPR) Cannot catch w/o much todo]
    1666 
    1667     [(SK (warn WARNING) EXPECTED TOL EXPR)
    1668       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1669         #'(tbm$expect-near/values-common STATE #f WARNING EXPECTED TOL EXPR))]
    1670 
    1671     [(SK MSG (warn WARNING) EXPECTED EXPR)
    1672       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1673         #'(tbm$expect-near/values-common STATE MSG WARNING EXPECTED EXPR))]
    1674 
    1675     [(SK MSG EXPECTED TOL EXPR)
    1676       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1677         #'(tbm$expect-near/values-common STATE MSG '() EXPECTED TOL EXPR))]
    1678 
    1679     [(SK MSG (warn WARNING) EXPECTED TOL EXPR)
    1680       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1681         #'(tbm$expect-near/values-common STATE MSG WARNING EXPECTED TOL EXPR))] ) )
     1648    [(SK EXPT EXPR)
     1649      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1650        #'(tbm$expect-near/values-common STATE #f '() EXPT EXPR))]
     1651
     1652    [(SK (warn WRNG) EXPT EXPR)
     1653      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1654        #'(tbm$expect-near/values-common STATE #f WRNG EXPT EXPR))]
     1655
     1656    [(SK MESG EXPT EXPR)
     1657      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1658        #'(tbm$expect-near/values-common STATE MESG '() EXPT EXPR))]
     1659
     1660    ;;[(SK EXPT TOL EXPR) Cannot catch w/o much todo]
     1661
     1662    [(SK (warn WRNG) EXPT TOL EXPR)
     1663      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1664        #'(tbm$expect-near/values-common STATE #f WRNG EXPT TOL EXPR))]
     1665
     1666    [(SK MESG (warn WRNG) EXPT EXPR)
     1667      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1668        #'(tbm$expect-near/values-common STATE MESG WRNG EXPT EXPR))]
     1669
     1670    [(SK MESG EXPT TOL EXPR)
     1671      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1672        #'(tbm$expect-near/values-common STATE MESG '() EXPT TOL EXPR))]
     1673
     1674    [(SK MESG (warn WRNG) EXPT TOL EXPR)
     1675      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1676        #'(tbm$expect-near/values-common STATE MESG WRNG EXPT TOL EXPR))] ) )
    16821677
    16831678;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    17051700(define-syntax tbm$expect-exception-common
    17061701  (syntax-rules ()
    1707     [(_ STATE MSG WARNING PATT EXPR)
    1708       (tbm$expect-exception STATE MSG WARNING "exception" PATT EXPR)] ) )
     1702    [(_ STATE MESG WRNG PATT EXPR)
     1703      (tbm$expect-exception STATE MESG WRNG "exception" PATT EXPR)] ) )
    17091704
    17101705(define-syntax (expect-exception X)
     
    17151710        #'(tbm$expect-exception-common STATE #f '() PATT EXPR))]
    17161711
    1717     [(SK (warn WARNING) PATT EXPR)
    1718       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1719         #'(tbm$expect-exception-common STATE #f WARNING PATT EXPR))]
    1720 
    1721     [(SK MSG PATT EXPR)
    1722       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1723         #'(tbm$expect-exception-common STATE MSG '() PATT EXPR))]
    1724 
    1725     [(SK MSG (warn WARNING) PATT EXPR)
    1726       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1727         #'(tbm$expect-exception-common STATE MSG WARNING PATT EXPR))] ) )
     1712    [(SK (warn WRNG) PATT EXPR)
     1713      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1714        #'(tbm$expect-exception-common STATE #f WRNG PATT EXPR))]
     1715
     1716    [(SK MESG PATT EXPR)
     1717      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1718        #'(tbm$expect-exception-common STATE MESG '() PATT EXPR))]
     1719
     1720    [(SK MESG (warn WRNG) PATT EXPR)
     1721      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1722        #'(tbm$expect-exception-common STATE MESG WRNG PATT EXPR))] ) )
    17281723
    17291724;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    17331728(define-syntax tbm$expect-every-ec-common
    17341729  (syntax-rules ()
    1735     [(_ STATE MSG WARNING PRED EXPECTED EXPR (QUAL ...) ...)
    1736       (tbm$expect-ec STATE MSG WARNING
     1730    [(_ STATE MESG WRNG PRED EXPT EXPR (QUAL ...) ...)
     1731      (tbm$expect-ec STATE MESG WRNG
    17371732        "ec" (cut tb$exptpred1 <> tb$true?)
    1738         every?-ec (PRED EXPECTED EXPR) (QUAL ...) ...)] ) )
     1733        every?-ec (PRED EXPT EXPR) (QUAL ...) ...)] ) )
    17391734
    17401735(define-syntax (expect-ec X)
    17411736  (syntax-case X (warn => :)
    17421737
    1743     [(SK (warn WARNING) (QUAL ...) ... EXPECTED => PRED EXPR)
    1744       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1745         #'(tbm$expect-every-ec-common STATE #f WARNING PRED EXPECTED EXPR (QUAL ...) ...))]
    1746 
    1747     [(SK (warn WARNING) (QUAL ...) ... EXPECTED => EXPR)
    1748       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1749         #'(tbm$expect-every-ec-common STATE #f WARNING equal? EXPECTED EXPR (QUAL ...) ...))]
    1750 
    1751     [(SK (warn WARNING) (QUAL ...) ... EXPECTED EXPR)
    1752       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1753         #'(tbm$expect-every-ec-common STATE #f WARNING equal? EXPECTED EXPR (QUAL ...) ...))]
    1754 
    1755     [(SK (QUAL ...) ... EXPECTED => PRED EXPR)
    1756       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1757         #'(tbm$expect-every-ec-common STATE #f '() PRED EXPECTED EXPR (QUAL ...) ...))]
    1758 
    1759     [(SK (QUAL ...) ... EXPECTED => EXPR)
    1760       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1761         #'(tbm$expect-every-ec-common STATE #f '() equal? EXPECTED EXPR (QUAL ...) ...))]
    1762 
    1763     [(SK (QUAL ...) ... EXPECTED EXPR)
    1764       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1765         #'(tbm$expect-every-ec-common STATE #f '() equal? EXPECTED EXPR (QUAL ...) ...))]
    1766 
    1767     [(SK MSG (warn WARNING) (QUAL ...) ... EXPECTED => PRED EXPR)
    1768       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1769         #'(tbm$expect-every-ec-common STATE MSG WARNING PRED EXPECTED EXPR (QUAL ...) ...))]
    1770 
    1771     [(SK MSG (warn WARNING) (QUAL ...) ... EXPECTED => EXPR)
    1772       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1773         #'(tbm$expect-every-ec-common STATE MSG WARNING equal? EXPECTED EXPR (QUAL ...) ...))]
    1774 
    1775     [(SK MSG (warn WARNING) (QUAL ...) ... EXPECTED EXPR)
    1776       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1777         #'(tbm$expect-every-ec-common STATE MSG WARNING equal? EXPECTED EXPR (QUAL ...) ...))]
    1778 
    1779     [(SK MSG (QUAL ...) ... EXPECTED => PRED EXPR)
    1780       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1781         #'(tbm$expect-every-ec-common STATE MSG '() PRED EXPECTED EXPR (QUAL ...) ...))]
    1782 
    1783     [(SK MSG (QUAL ...) ... EXPECTED => EXPR)
    1784       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1785         #'(tbm$expect-every-ec-common STATE MSG '() equal? EXPECTED EXPR (QUAL ...) ...))]
    1786 
    1787     [(SK MSG (QUAL ...) ... EXPECTED EXPR)
    1788       (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1789         #'(tbm$expect-every-ec-common STATE MSG '() equal? EXPECTED EXPR (QUAL ...) ...))] ) )
     1738    [(SK (warn WRNG) (QUAL ...) ... EXPT => PRED EXPR)
     1739      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1740        #'(tbm$expect-every-ec-common STATE #f WRNG PRED EXPT EXPR (QUAL ...) ...))]
     1741
     1742    [(SK (warn WRNG) (QUAL ...) ... EXPT => EXPR)
     1743      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1744        #'(tbm$expect-every-ec-common STATE #f WRNG equal? EXPT EXPR (QUAL ...) ...))]
     1745
     1746    [(SK (warn WRNG) (QUAL ...) ... EXPT EXPR)
     1747      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1748        #'(tbm$expect-every-ec-common STATE #f WRNG equal? EXPT EXPR (QUAL ...) ...))]
     1749
     1750    [(SK (QUAL ...) ... EXPT => PRED EXPR)
     1751      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1752        #'(tbm$expect-every-ec-common STATE #f '() PRED EXPT EXPR (QUAL ...) ...))]
     1753
     1754    [(SK (QUAL ...) ... EXPT => EXPR)
     1755      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1756        #'(tbm$expect-every-ec-common STATE #f '() equal? EXPT EXPR (QUAL ...) ...))]
     1757
     1758    [(SK (QUAL ...) ... EXPT EXPR)
     1759      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1760        #'(tbm$expect-every-ec-common STATE #f '() equal? EXPT EXPR (QUAL ...) ...))]
     1761
     1762    [(SK MESG (warn WRNG) (QUAL ...) ... EXPT => PRED EXPR)
     1763      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1764        #'(tbm$expect-every-ec-common STATE MESG WRNG PRED EXPT EXPR (QUAL ...) ...))]
     1765
     1766    [(SK MESG (warn WRNG) (QUAL ...) ... EXPT => EXPR)
     1767      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1768        #'(tbm$expect-every-ec-common STATE MESG WRNG equal? EXPT EXPR (QUAL ...) ...))]
     1769
     1770    [(SK MESG (warn WRNG) (QUAL ...) ... EXPT EXPR)
     1771      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1772        #'(tbm$expect-every-ec-common STATE MESG WRNG equal? EXPT EXPR (QUAL ...) ...))]
     1773
     1774    [(SK MESG (QUAL ...) ... EXPT => PRED EXPR)
     1775      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1776        #'(tbm$expect-every-ec-common STATE MESG '() PRED EXPT EXPR (QUAL ...) ...))]
     1777
     1778    [(SK MESG (QUAL ...) ... EXPT => EXPR)
     1779      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1780        #'(tbm$expect-every-ec-common STATE MESG '() equal? EXPT EXPR (QUAL ...) ...))]
     1781
     1782    [(SK MESG (QUAL ...) ... EXPT EXPR)
     1783      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1784        #'(tbm$expect-every-ec-common STATE MESG '() equal? EXPT EXPR (QUAL ...) ...))] ) )
    17901785
    17911786;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    18201815(define-syntax tbm$expect-set-common!
    18211816  (syntax-rules ()
    1822     [(_ STATE MSG WARNING VAR EXPR)
    1823       (let ([result (tbm$expect-success-common STATE MSG WARNING EXPR)])
     1817    [(_ STATE MESG WRNG VAR EXPR)
     1818      (let ([result (tbm$expect-success-common STATE MESG WRNG EXPR)])
    18241819        (when (test::expect-result? result)
    18251820          (set! VAR (test::expect-result-evaled result)))
     
    18391834        (identifier? #'VAR)
    18401835        (with-syntax ([STATE (tbs$state-synobj #'SK)]
    1841                       [MSG (setvarmsg-synobj #'SK #'VAR #'EXPR)])
    1842           #'(tbm$expect-set-common! STATE MSG '() VAR EXPR))]
    1843 
    1844       [(SK (warn WARNING) VAR EXPR)
     1836                      [MESG (setvarmsg-synobj #'SK #'VAR #'EXPR)])
     1837          #'(tbm$expect-set-common! STATE MESG '() VAR EXPR))]
     1838
     1839      [(SK (warn WRNG) VAR EXPR)
    18451840        (identifier? #'VAR)
    18461841        (with-syntax ([STATE (tbs$state-synobj #'SK)]
    1847                       [MSG (setvarmsg-synobj #'SK #'VAR #'EXPR)])
    1848           #'(tbm$expect-set-common! STATE MSG WARNING VAR EXPR))]
    1849 
    1850       [(SK MSG VAR EXPR)
     1842                      [MESG (setvarmsg-synobj #'SK #'VAR #'EXPR)])
     1843          #'(tbm$expect-set-common! STATE MESG WRNG VAR EXPR))]
     1844
     1845      [(SK MESG VAR EXPR)
    18511846        (identifier? #'VAR)
    18521847        (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1853           #'(tbm$expect-set-common! STATE MSG '() VAR EXPR))]
    1854 
    1855       [(SK MSG (warn WARNING) VAR EXPR)
     1848          #'(tbm$expect-set-common! STATE MESG '() VAR EXPR))]
     1849
     1850      [(SK MESG (warn WRNG) VAR EXPR)
    18561851        (identifier? #'VAR)
    18571852        (with-syntax ([STATE (tbs$state-synobj #'SK)])
    1858           #'(tbm$expect-set-common! STATE MSG WARNING VAR EXPR))] ) ) )
     1853          #'(tbm$expect-set-common! STATE MESG WRNG VAR EXPR))] ) ) )
    18591854
    18601855;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    18761871  (syntax-case X ()
    18771872
    1878     [(SK EXPR EXPECTED)
     1873    [(SK EXPR EXPT)
    18791874      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    18801875        #'(tbm$expect-binary/values STATE
    1881           #f '() "eq" (cut tb$exptvalspred2 <> <> eq?) EXPECTED EXPR))]
    1882 
    1883     [(SK DESC EXPR EXPECTED)
     1876          #f '() "eq" (cut tb$exptvalspred2 <> <> eq?) EXPT EXPR))]
     1877
     1878    [(SK DESC EXPR EXPT)
    18841879      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    18851880        #'(tbm$expect-binary/values STATE
    1886           DESC '() "eq" (cut tb$exptvalspred2 <> <> eq?) EXPECTED EXPR))] ) )
     1881          DESC '() "eq" (cut tb$exptvalspred2 <> <> eq?) EXPT EXPR))] ) )
    18871882
    18881883(define-syntax (test/eqv X)
    18891884  (syntax-case X ()
    18901885
    1891     [(SK EXPR EXPECTED)
     1886    [(SK EXPR EXPT)
    18921887      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    18931888        #'(tbm$expect-binary/values STATE
    1894           #f '() "eqv" (cut tb$exptvalspred2 <> <> eqv?) EXPECTED EXPR))]
    1895 
    1896     [(SK DESC EXPR EXPECTED)
     1889          #f '() "eqv" (cut tb$exptvalspred2 <> <> eqv?) EXPT EXPR))]
     1890
     1891    [(SK DESC EXPR EXPT)
    18971892      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    18981893        #'(tbm$expect-binary/values STATE
    1899           DESC '() "eqv" (cut tb$exptvalspred2 <> <> eqv?) EXPECTED EXPR))] ) )
     1894          DESC '() "eqv" (cut tb$exptvalspred2 <> <> eqv?) EXPT EXPR))] ) )
    19001895
    19011896(define-syntax (test/equal X)
    19021897  (syntax-case X ()
    19031898
    1904     [(SK EXPR EXPECTED)
     1899    [(SK EXPR EXPT)
    19051900      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    19061901        #'(tbm$expect-binary/values STATE
    1907           #f '() "equal" (cut tb$exptvalspred2 <> <> equal?) EXPECTED EXPR))]
    1908 
    1909     [(SK DESC EXPR EXPECTED)
     1902          #f '() "equal" (cut tb$exptvalspred2 <> <> equal?) EXPT EXPR))]
     1903
     1904    [(SK DESC EXPR EXPT)
    19101905      (with-syntax ([STATE (tbs$state-synobj #'SK)])
    19111906        #'(tbm$expect-binary/values STATE
    1912           DESC '() "equal" (cut tb$exptvalspred2 <> <> equal?) EXPECTED EXPR))] ) )
     1907          DESC '() "equal" (cut tb$exptvalspred2 <> <> equal?) EXPT EXPR))] ) )
     1908
     1909;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     1910;; Assert'ish form
     1911;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     1912
     1913(define-syntax (tbm$insist-common X)
     1914  (syntax-case X ()
     1915    [(SK STATE MESG WRNG EXPR PRED EXPT)
     1916      (identifier? #'PRED)
     1917      (with-syntax ([KIND (tbs$suffstr-synobj #'SK #'PRED)])
     1918        #'(tbm$expect-binary STATE
     1919            MESG WRNG
     1920            KIND (cut tb$exptpred2 <> <> PRED) EXPT EXPR) ) ] ) )
     1921
     1922(define-syntax (insist X)
     1923  (syntax-case X (warn =>)
     1924
     1925    [(SK EXPR => EXPT)
     1926      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1927        #'(tbm$insist-common STATE #f '() EXPR equal? EXPT) ) ]
     1928
     1929    [(SK (warn WRNG) EXPR => EXPT)
     1930      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1931        #'(tbm$insist-common STATE #f WRNG EXPR equal? EXPT) ) ]
     1932
     1933    [(SK MESG EXPR => EXPT)
     1934      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1935        #'(tbm$insist-common STATE MESG '() EXPR equal? EXPT) ) ]
     1936
     1937    [(SK MESG (warn WRNG) EXPR => EXPT)
     1938      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1939        #'(tbm$insist-common STATE MESG WRNG EXPR equal? EXPT) ) ]
     1940
     1941    [(SK EXPR (=> PRED) EXPT)
     1942      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1943        #'(tbm$insist-common STATE #f '() EXPR PRED EXPT) ) ]
     1944
     1945    [(SK (warn WRNG) EXPR (=> PRED) EXPT)
     1946      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1947        #'(tbm$insist-common STATE #f WRNG EXPR PRED EXPT) ) ]
     1948
     1949    [(SK MESG EXPR (=> PRED) EXPT)
     1950      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1951        #'(tbm$insist-common STATE MESG '() EXPR PRED EXPT) ) ]
     1952
     1953    [(SK MESG (warn WRNG) EXPR (=> PRED) EXPT)
     1954      (with-syntax ([STATE (tbs$state-synobj #'SK)])
     1955        #'(tbm$insist-common STATE MESG WRNG EXPR PRED EXPT) ) ] ) )
     1956
     1957;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     1958;; Build paragraph form
     1959;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     1960
     1961;; This is needed due to a testbase bug!
     1962
     1963(define-for-syntax (MULTILINE-STRING . lines)
     1964  (string-append (apply string-append (intersperse lines "\n") "\n")) )
  • release/3/testbase/testbase-version.scm

    r8424 r8490  
    11;;;; testbase-version.scm
    22
    3 (define-constant TESTBASE-VERSION "1.41")
     3(define-constant TESTBASE-VERSION "1.5")
  • release/3/testbase/testbase.html

    r8424 r8490  
    4646<li><a href="#naming">Macro and Procedure Naming Conventions</a></li>
    4747<li><a href="#option-expansion">Option Expansion Control</a></li>
     48<li><a href="#bug-workaround">Multiline String Construction</a></li>
    4849<li><a href="#immediate-test">Immediate Test</a></li>
    4950<li><a href="#test-definition">Test Procedure Definition</a></li>
     
    155156
    156157<li><code>test::catching</code> controls the expectation error/exception
    157 trapping option. Dropping catching is not suggested in the general case, since
    158 any intermediate errors will abort the entire test. Does not affect
    159 <code>expect-exception</code>. Default is <code>#t</code>.</li>
     158trapping option. Default is <code>#t</code>.</li>
    160159
    161160<li><code>test::selecting</code> controls the test selective evaluation option. Default is <code>#f</code>.</li>
     
    164163</ul>
    165164
     165<p> Dropping error/exception trapping is not suggested in the general case,
     166since any intermediate errors will abort the entire test. Does not affect
     167<code>expect-exception</code>.</p>
     168
     169
     170<h4><a name="bug-workaround">Multiline String Construction</a></h4>
     171
     172<p>Due to a bug the Chicken multiline string forms cannot be used. This macro
     173is provided as a workaround.</p>
     174
     175<dl>
     176<dt>[<em>syntax</em>] <code>MULTILINE-STRING</code></dt>
     177<dd><br/>(MULTILINE-STRING STRING ...)<br/></dd>
     178<dd>
     179<ul>
     180<ul>
     181<li>Yes, the macro name is uppercase.</li>
     182
     183<li><code>STRING</code> is any scheme string. The strings are suffixed with a
     184newline and concatenated.</li>
     185</ul>
     186</dd>
     187</dl>
     188
    166189
    167190<h4><a name="immediate-test">Immediate Test</a></h4>
     
    172195
    173196<dl>
    174 <dt><em>(macro)</em><code> test</code></dt>
    175 <dd><br />
    176 (test (EXPECTED EXPRESSION) ...)
    177 <br /></dd>
     197<dt>[<em>syntax</em>] <code>test</code></dt>
     198<dd><br/>(test (EXPECTED EXPRESSION) ...)<br/></dd>
    178199<dd>
    179200<ul>
     
    192213
    193214<dl>
    194 <dt><em>(macro)</em><code> define-test</code></dt>
    195 <dd><br />
     215<dt>[<em>syntax</em>] <code>define-test</code></dt>
     216<dd><br/>
    196217(define-test PROCEDURE-VARIABLE [TEST-NAME] [(initial FORM ...)] [(final FORM ...)] CLAUSE ...)
    197 <br />
     218<br/>
    198219(define-test (PROCEDURE-VARIABLE VARIABLE ...) [TEST-NAME] [(initial FORM ...)] [(final FORM ...)] CLAUSE ...)
    199 <br /></dd>
     220<br/></dd>
    200221<dd>
    201222<ul>
     
    220241<code>FORM</code> can be any Scheme form legal at the end of a
    221242<code>lambda</code> body. The <code>final</code> section will be evaluated
    222 after the last <code>CLAUSE</code> and before the desctructor is
     243after the last <code>CLAUSE</code> and before the destructor is
    223244activated!</li>
    224245
     
    250271
    251272<dl>
    252 <dt><em>(macro)</em><code> declare-test</code></dt>
    253 <dd><br />
    254 (declare-test PROCEDURE-VARIABLE TEST-NAME ARGUMENT ...)
    255 <br /></dd>
     273<dt>[<em>syntax</em>] <code>declare-test</code></dt>
     274<dd><br/>(declare-test PROCEDURE-VARIABLE TEST-NAME ARGUMENT ...)<br/></dd>
    256275<dd>
    257276<ul>
     
    284303
    285304<dl>
    286 <dt><em>(procedure)</em><code> test::procedure?</code></dt>
    287 <dd><br />
    288 (test::procedure? OBJECT)
    289 <br /></dd>
     305<dt>[<em>procedure</em>] <code>test::procedure?</code></dt>
     306<dd><br/>(test::procedure? OBJECT)<br/></dd>
    290307<dd>
    291308<ul>
     
    296313
    297314<dl>
    298 <dt><em>(procedure)</em><code> test::formal-arguments</code></dt>
    299 <dd><br />
    300 (test::formal-arguments TEST-IDENTIFIER)
    301 <br /></dd>
     315<dt>[<em>procedure</em>] <code>test::formal-arguments</code></dt>
     316<dd><br/>(test::formal-arguments TEST-IDENTIFIER)<br/></dd>
    302317<dd>
    303318<ul>
     
    308323
    309324<dl>
    310 <dt><em>(procedure)</em><code> test::declarations</code></dt>
    311 <dd><br />
    312 (test::declarations TEST-IDENTIFIER)
    313 <br /></dd>
     325<dt>[<em>procedure</em>] <code>test::declarations</code></dt>
     326<dd><br/>(test::declarations TEST-IDENTIFIER)<br/></dd>
    314327<dd>
    315328<ul>
     
    322335
    323336<dl>
    324 <dt><em>(procedure)</em><code> test::procedure</code></dt>
    325 <dd><br />
    326 (test::procedure TEST-IDENTIFIER)
    327 <br /></dd>
     337<dt>[<em>procedure</em>] <code>test::procedure</code></dt>
     338<dd><br/>(test::procedure TEST-IDENTIFIER)<br/></dd>
    328339<dd>
    329340<ul>
     
    334345
    335346<dl>
    336 <dt><em>(procedure)</em><code> test::name</code></dt>
    337 <dd><br />
    338 (test::name TEST-IDENTIFIER)
    339 <br /></dd>
     347<dt>[<em>procedure</em>] <code>test::name</code></dt>
     348<dd><br/>(test::name TEST-IDENTIFIER)<br/></dd>
    340349<dd>
    341350<ul>
     
    346355
    347356<dl>
    348 <dt><em>(procedure)</em><code> test::procedure-variable</code></dt>
    349 <dd><br />
    350 (test::procedure-variable TEST-IDENTIFIER)
    351 <br /></dd>
     357<dt>[<em>procedure</em>] <code>test::procedure-variable</code></dt>
     358<dd><br/>(test::procedure-variable TEST-IDENTIFIER)<br/></dd>
    352359<dd>
    353360<ul>
     
    358365
    359366<dl>
    360 <dt><em>(procedure)</em><code> test::styler</code></dt>
    361 <dd><br />
    362 (test::styler TEST-IDENTIFIER)
    363 <br /></dd>
     367<dt>[<em>procedure</em>] <code>test::styler</code></dt>
     368<dd><br/>(test::styler TEST-IDENTIFIER)<br/></dd>
    364369<dd>
    365370<ul>
     
    371376
    372377<dl>
    373 <dt><em>(procedure)</em><code> test::styler-set!</code></dt>
    374 <dd><br />
    375 (test::styler-set! TEST-IDENTIFIER [STYLER])
    376 <br /></dd>
     378<dt>[<em>procedure</em>] <code>test::styler-set!</code></dt>
     379<dd><br/>(test::styler-set! TEST-IDENTIFIER [STYLER])<br/></dd>
    377380<dd>
    378381<ul>
     
    384387
    385388<dl>
    386 <dt><em>(procedure)</em><code> test::tolerance</code></dt>
    387 <dd><br />
    388 (test::tolerance TEST-IDENTIFIER)
    389 <br /></dd>
     389<dt>[<em>procedure</em>] <code>test::tolerance</code></dt>
     390<dd><br/>(test::tolerance TEST-IDENTIFIER)<br/></dd>
    390391<dd>
    391392<ul>
     
    397398
    398399<dl>
    399 <dt><em>(procedure)</em><code> test::tolerance-set!</code></dt>
    400 <dd><br />
    401 (test::tolerance-set! TEST-IDENTIFIER TOLERANCE)
    402 <br /></dd>
     400<dt>[<em>procedure</em>] <code>test::tolerance-set!</code></dt>
     401<dd><br/>(test::tolerance-set! TEST-IDENTIFIER TOLERANCE)<br/></dd>
    403402<dd>
    404403<ul>
     
    410409
    411410<dl>
    412 <dt><em>(procedure)</em><code> test::reset!</code></dt>
    413 <dd><br />
    414 (test::reset! TEST-IDENTIFIER)
    415 <br /></dd>
     411<dt>[<em>procedure</em>] <code>test::reset!</code></dt>
     412<dd><br/>(test::reset! TEST-IDENTIFIER)<br/></dd>
    416413<dd>
    417414<ul>
     
    422419
    423420<dl>
    424 <dt><em>(procedure)</em><code> test::structure</code></dt>
    425 <dd><br />
    426 (test::structure TEST-IDENTIFIER)
    427 <br /></dd>
     421<dt>[<em>procedure</em>] <code>test::structure</code></dt>
     422<dd><br/>(test::structure TEST-IDENTIFIER)<br/></dd>
    428423<dd>
    429424<ul>
     
    441436
    442437<dl>
    443 <dt><em>(procedure)</em><code> test::add-filter!</code></dt>
    444 <dd><br />
    445 (test::add-filter! TEST-IDENTIFIER FILTER-PROCEDURE)
    446 <br /></dd>
     438<dt>[<em>procedure</em>] <code>test::add-filter!</code></dt>
     439<dd><br/>(test::add-filter! TEST-IDENTIFIER FILTER-PROCEDURE)<br/></dd>
    447440<dd>
    448441<ul>
     
    451444
    452445<li><code>FILTER-PROCEDURE</code> must be a procedure of one argument, a test
    453 result object, and it must return a test result object. Not necessarially the
     446result object, and it must return a test result object. Not necessarily the
    454447same one.</li>
    455448
     
    460453
    461454<dl>
    462 <dt><em>(procedure)</em><code> test::remove-filter!</code></dt>
    463 <dd><br />
    464 (test::remove-filter! TEST-IDENTIFIER FILTER-PROCEDURE)
    465 <br /></dd>
     455<dt>[<em>procedure</em>] <code>test::remove-filter!</code></dt>
     456<dd><br/>(test::remove-filter! TEST-IDENTIFIER FILTER-PROCEDURE)<br/></dd>
    466457<dd>
    467458<ul>
     
    473464
    474465<dl>
    475 <dt><em>(procedure)</em><code> test::add-echo!</code></dt>
    476 <dd><br />
    477 (test::add-echo! TEST-IDENTIFIER [PORT] [KEY VALUE ...])
    478 <br /></dd>
     466<dt>[<em>procedure</em>] <code>test::add-echo!</code></dt>
     467<dd><br/>(test::add-echo! TEST-IDENTIFIER [PORT] [KEY VALUE ...])<br/></dd>
    479468<dd>
    480469<ul>
     
    500489
    501490<dl>
    502 <dt><em>(procedure)</em><code> test::remove-echo!</code></dt>
    503 <dd><br />
    504 (test::remove-echo! TEST-IDENTIFIER [PORT])
    505 <br /></dd>
     491<dt>[<em>procedure</em>] <code>test::remove-echo!</code></dt>
     492<dd><br/>(test::remove-echo! TEST-IDENTIFIER [PORT])<br/></dd>
    506493<dd>
    507494<ul>
     
    512499
    513500<dl>
    514 <dt><em>(procedure)</em><code> test::set-echo-option!</code></dt>
    515 <dd><br />
    516 (test::set-echo-option! TEST-IDENTIFIER [PORT] [KEY VALUE ...])
    517 <br /></dd>
    518 <dd>
    519 <ul>
    520 <li>Modifies the echo specification for the specifed <code>PORT</code>.</li>
     501<dt>[<em>procedure</em>] <code>test::set-echo-option!</code></dt>
     502<dd><br/>(test::set-echo-option! TEST-IDENTIFIER [PORT] [KEY VALUE ...])<br/></dd>
     503<dd>
     504<ul>
     505<li>Modifies the echo specification for the specified <code>PORT</code>.</li>
    521506
    522507<li>The <code>PORT</code>, <code>KEY</code>, and <code>VALUE</code> parameters have the same interpretation as the <code>test::add-echo!</code> procedure.</li>
     
    526511
    527512<dl>
    528 <dt><em>(procedure)</em><code> test::run-mode</code></dt>
    529 <dd><br />
    530 (test::run-mode)
    531 <br /></dd>
     513<dt>[<em>procedure</em>] <code>test::run-mode</code></dt>
     514<dd><br/>(test::run-mode)<br/></dd>
    532515<dd>
    533516<ul>
     
    538521
    539522<dl>
    540 <dt><em>(procedure)</em><code> test::selection-mode</code></dt>
    541 <dd><br />
    542 (test::selection-mode TEST-IDENTIFIER)
    543 <br /></dd>
     523<dt>[<em>procedure</em>] <code>test::selection-mode</code></dt>
     524<dd><br/>(test::selection-mode TEST-IDENTIFIER)<br/></dd>
    544525<dd>
    545526<ul>
     
    556537
    557538<dl>
    558 <dt><em>(procedure)</em><code> test::select!</code></dt>
    559 <dd><br />
    560 (test::take! SELECTION-MODE TEST-IDENTIFIER [TEST-NAME | (TEST-TYPE TEST-NAME)] ...)
    561 <br /></dd>
     539<dt>[<em>procedure</em>] <code>test::select!</code></dt>
     540<dd><br/>(test::take! SELECTION-MODE TEST-IDENTIFIER [TEST-NAME | (TEST-TYPE TEST-NAME)] ...)<br/></dd>
    562541<dd>
    563542<ul>
     
    588567
    589568<dl>
    590 <dt><em>(procedure)</em><code> test::selections</code></dt>
    591 <dd><br />
    592 (test::selections TEST-IDENTIFIER)
    593 <br /></dd>
     569<dt>[<em>procedure</em>] <code>test::selections</code></dt>
     570<dd><br/>(test::selections TEST-IDENTIFIER)<br/></dd>
    594571<dd>
    595572<ul>
     
    602579
    603580<dl>
    604 <dt><em>(procedure)</em><code> test::resource-limit</code></dt>
    605 <dd><br />
    606 (test::resource-limit TEST-IDENTIFIER RLIMIT)
    607 <br /></dd>
     581<dt>[<em>procedure</em>] <code>test::resource-limit</code></dt>
     582<dd><br/>(test::resource-limit TEST-IDENTIFIER RLIMIT)<br/></dd>
    608583<dd>
    609584<ul>
     
    621596
    622597<dl>
    623 <dt><em>(procedure)</em><code> test::resource-limit-set!</code></dt>
    624 <dd><br />
    625 (test::resource-limit-set! TEST-IDENTIFIER RLIMIT VALUE)
    626 <br /></dd>
     598<dt>[<em>procedure</em>] <code>test::resource-limit-set!</code></dt>
     599<dd><br/>(test::resource-limit-set! TEST-IDENTIFIER RLIMIT VALUE)<br/></dd>
    627600<dd>
    628601<ul>
     
    651624
    652625<dl>
    653 <dt><em>(procedure)</em><code> test::procedures</code></dt>
    654 <dd><br />
    655 (test::procedures)
    656 <br /></dd>
     626<dt>[<em>procedure</em>] <code>test::procedures</code></dt>
     627<dd><br/>(test::procedures)<br/></dd>
    657628<dd>
    658629<ul>
     
    663634
    664635<dl>
    665 <dt><em>(procedure)</em><code> test::for-each</code></dt>
    666 <dd><br />
    667 (test::for-each PROCEDURE [TEST-IDENTIFIER ...])
    668 <br /></dd>
    669 <dd>
    670 <ul>
    671 <li>Calls <code>PROCEDURE</code> with every supplied test procdure, or all test
     636<dt>[<em>procedure</em>] <code>test::for-each</code></dt>
     637<dd><br/>(test::for-each PROCEDURE [TEST-IDENTIFIER ...])<br/></dd>
     638<dd>
     639<ul>
     640<li>Calls <code>PROCEDURE</code> with every supplied test procedure, or all test
    672641procedures when nothing supplied.</li>
    673642
     
    678647
    679648<dl>
    680 <dt><em>(procedure)</em><code> test::map</code></dt>
    681 <dd><br />
    682 (test::map PROCEDURE [TEST-IDENTIFIER ...])
    683 <br /></dd>
    684 <dd>
    685 <ul>
    686 <li>Calls <code>PROCEDURE</code> with every supplied test procdure, or all test
     649<dt>[<em>procedure</em>] <code>test::map</code></dt>
     650<dd><br/>(test::map PROCEDURE [TEST-IDENTIFIER ...])<br/></dd>
     651<dd>
     652<ul>
     653<li>Calls <code>PROCEDURE</code> with every supplied test procedure, or all test
    687654procedures when nothing supplied. Returns a list of the procedure results.</li>
    688655
     
    693660
    694661<dl>
    695 <dt><em>(procedure)</em><code> test::forget!</code></dt>
    696 <dd><br />
    697 (test::forget! [TEST-IDENTIFIER ...])
    698 <br /></dd>
     662<dt>[<em>procedure</em>] <code>test::forget!</code></dt>
     663<dd><br/>(test::forget! [TEST-IDENTIFIER ...])<br/></dd>
    699664<dd>
    700665<ul>
     
    708673
    709674<dl>
    710 <dt><em>(procedure)</em><code> test::run</code></dt>
    711 <dd><br />
    712 (test::run [MESSAGE [TEST-IDENTIFIER ...]])
    713 <br /></dd>
     675<dt>[<em>procedure</em>] <code>test::run</code></dt>
     676<dd><br/>(test::run [MESSAGE [TEST-IDENTIFIER ...]])<br/></dd>
    714677<dd>
    715678<ul>
     
    742705
    743706<dl>
    744 <dt><em>(macro)</em><code> run-test</code></dt>
    745 <dd><br />
    746 (run-test [MESSAGE] [FORM ...])
    747 <br /></dd>
     707<dt>[<em>syntax</em>] <code>run-test</code></dt>
     708<dd><br/>(run-test [MESSAGE] [FORM ...])<br/></dd>
    748709<dd>
    749710<ul>
     
    788749
    789750<dl>
    790 <dt><em>(macro)</em><code> test-suite</code></dt>
    791 <dd><br />
     751<dt>[<em>syntax</em>] <code>test-suite</code></dt>
     752<dd><br/>
    792753(test-suite TEST-NAME DTOR-NAME ESCR-NAME [(warn MESSAGE)] [((VARIABLE VALUE) ...)] CLAUSE ...)
    793 <br />
     754<br/>
    794755(test/suite TEST-NAME [((VARIABLE VALUE) ...)] CLAUSE ...)
    795 <br /></dd>
     756<br/></dd>
    796757<dd>
    797758<ul>
     
    838799
    839800<dl>
    840 <dt><em>(macro)</em><code> test-case</code></dt>
    841 <dd><br />
     801<dt>[<em>syntax</em>] <code>test-case</code></dt>
     802<dd><br/>
    842803(test-case TEST-NAME DTOR-NAME ESCR-NAME [(warn MESSAGE)] [((VARIABLE VALUE) ...)] CLAUSE ...)
    843 <br />
     804<br/>
    844805(test/case TEST-NAME [((VARIABLE VALUE) ...)] CLAUSE ...)
    845 <br /></dd>
     806<br/></dd>
    846807<dd>
    847808<ul>
     
    886847
    887848<dl>
    888 <dt><em>(macro)</em><code> test-collect</code></dt>
    889 <dd><br />
     849<dt>[<em>syntax</em>] <code>test-collect</code></dt>
     850<dd><br/>
    890851(test-collect TEST-NAME DTOR-NAME ESCR-NAME [(warn MESSAGE)] [((VARIABLE VALUE) ...)] EXPRESSION ...)
    891 <br />
     852<br/>
    892853(test/collect TEST-NAME [((VARIABLE VALUE) ...)] EXPRESSION ...)
    893 <br /></dd>
     854<br/></dd>
    894855<dd>
    895856<ul>
     
    924885<li><code>EXPRESSION</code> is either an arbitrary Scheme expression or the form <code>(collect-test CLAUSE)</code>, where <code>CLAUSE</code> is a use of a test container, annotation, or expectation macro. The expressions are evaluated in a left to right fashion.</li>
    925886
    926 <li>The <code>collect-test</code> macro "appends" the test result of the <code>CLAUSE</code> to the results of the enclosing test collect containter.</li>
     887<li>The <code>collect-test</code> macro "appends" the test result of the <code>CLAUSE</code> to the results of the enclosing test collect container.</li>
    927888
    928889<li><b>Note</b> that upon discovery of a failed expectation, the test collect
     
    941902
    942903<dl>
    943 <dt><em>(macro)</em><code> test-case-evaluate-thru-failure</code></dt>
    944 <dd><br />
    945 (test-case-evaluate-thru-failure BOOLEAN)
    946 <br /></dd>
     904<dt>[<em>syntax</em>] <code>test-case-evaluate-thru-failure</code></dt>
     905<dd><br/>(test-case-evaluate-thru-failure BOOLEAN)<br/></dd>
    947906<dd>
    948907<ul>
     
    955914
    956915<dl>
    957 <dt><em>(macro)</em><code> test-timing</code></dt>
    958 <dd><br />
    959 (test-timing BOOLEAN)
    960 <br /></dd>
     916<dt>[<em>syntax</em>] <code>test-timing</code></dt>
     917<dd><br/>(test-timing BOOLEAN)<br/></dd>
    961918<dd>
    962919<ul>
     
    971928
    972929<dl>
    973 <dt><em>(macro)</em><code> test-evaluation-mode?</code></dt>
    974 <dd><br />
    975 (test-evaluation-mode?)
    976 <br /></dd>
     930<dt>[<em>syntax</em>] <code>test-evaluation-mode?</code></dt>
     931<dd><br/>(test-evaluation-mode?)<br/></dd>
    977932<dd>
    978933<ul>
     
    988943
    989944<dl>
    990 <dt><em>(macro)</em><code> test-letrec</code></dt>
    991 <dd><br />
    992 (test-letrec ((VARIABLE VALUE) ...) CLAUSE ...)
    993 <br /></dd>
     945<dt>[<em>syntax</em>] <code>test-letrec</code></dt>
     946<dd><br/>(test-letrec ((VARIABLE VALUE) ...) CLAUSE ...)<br/></dd>
    994947<dd>
    995948<ul>
     
    1006959
    1007960<dl>
    1008 <dt><em>(macro)</em><code> test-let*</code></dt>
    1009 <dd><br />
    1010 (test-let* ((VARIABLE VALUE) ...) CLAUSE ...)
    1011 <br /></dd>
     961<dt>[<em>syntax</em>] <code>test-let*</code></dt>
     962<dd><br/>(test-let* ((VARIABLE VALUE) ...) CLAUSE ...)<br/></dd>
    1012963<dd>
    1013964<ul>
     
    1024975
    1025976<dl>
    1026 <dt><em>(macro)</em><code> test-let</code></dt>
    1027 <dd><br />
    1028 (test-let ((VARIABLE VALUE) ...) CLAUSE ...)
    1029 <br /></dd>
     977<dt>[<em>syntax</em>] <code>test-let</code></dt>
     978<dd><br/>(test-let ((VARIABLE VALUE) ...) CLAUSE ...)<br/></dd>
    1030979<dd>
    1031980<ul>
     
    1046995<p>An expectation at its core simply evaluates its arguments and check to see
    1047996if it matches the expectation. The positive or negative result is encapsulated,
    1048 along with other things such as the un-evaluated expressions being checked and
     997along with other things such as the unevaluated expressions being checked and
    1049998some messages supplied with each expectation into a particular type of black
    1050999box object that one can query with the appropriate API calls (detailed
     
    10661015<dl>
    10671016
    1068 <dt><em>(macro)</em><code> expect-unary</code></dt>
    1069 <dd><br />
    1070 (expect-unary [TEST-NAME] [(warn MESSAGE)] KIND PREDICATE EXPRESSION)
    1071 <br /></dd>
     1017<dt>[<em>syntax</em>] <code>insist</code></dt>
     1018<dd><br/>(insist [TEST-NAME] [(warn MESSAGE)] EXPRESSION => EXPECTED)<br/></dd>
     1019<dd><br/>(insist [TEST-NAME] [(warn MESSAGE)] EXPRESSION (=> PREDICATE) EXPECTED)<br/></dd>
    10721020<dd>
    10731021<ul>
    10741022<li>This expectation checks to see if the evaluated expression passed to it
    1075 meets the predicate condition. Allows unary and binary predicates.</li>
     1023meets the predicate condition.</li>
    10761024
    10771025<li><code>TEST-NAME</code> must evaluate to a Scheme <code>atom</code>.</li>
     
    10811029function name is actually a syntax reserved word in the macro.</li>
    10821030
    1083 <li><code>KIND</code> is a string stating the kind of test.</li>
    1084 
    1085 <li><code>PREDICATE</code> is a procedure of one argument to perform the
    1086 test.</li>
     1031<li><code>PREDICATE</code> is a procedure of two arguments to perform the
     1032test. The default is <code>equal?</code>.</li>
     1033
     1034<li><code>EXPECTED</code> is evaluated and represents the value the
     1035<code>EXPRESSION</code> <em>must</em> match via <code>PREDICATE</code> in order
     1036for this expectation to return a positive result.</li>
    10871037
    10881038<li><code>EXPRESSION</code> should return a value meeting the conditions of the
     
    10911041</dd>
    10921042
    1093 <dt><em>(macro)</em><code> expect-binary</code></dt>
    1094 <dd><br />
    1095 (expect-binary [TEST-NAME] [(warn MESSAGE)] KIND PREDICATE EXPECTED EXPRESSION)
    1096 <br /></dd>
     1043<dt>[<em>syntax</em>] <code>expect-unary</code></dt>
     1044<dd><br/>(expect-unary [TEST-NAME] [(warn MESSAGE)] KIND PREDICATE EXPRESSION)<br/></dd>
    10971045<dd>
    10981046<ul>
     
    11081056<li><code>KIND</code> is a string stating the kind of test.</li>
    11091057
     1058<li><code>PREDICATE</code> is a procedure of one argument to perform the
     1059test.</li>
     1060
     1061<li><code>EXPRESSION</code> should return a value meeting the conditions of the
     1062predicate.</li>
     1063</ul>
     1064</dd>
     1065
     1066<dt>[<em>syntax</em>] <code>expect-binary</code></dt>
     1067<dd><br/>(expect-binary [TEST-NAME] [(warn MESSAGE)] KIND PREDICATE EXPECTED EXPRESSION)<br/></dd>
     1068<dd>
     1069<ul>
     1070<li>This expectation checks to see if the evaluated expression passed to it
     1071meets the predicate condition. Allows unary and binary predicates.</li>
     1072
     1073<li><code>TEST-NAME</code> must evaluate to a Scheme <code>atom</code>.</li>
     1074
     1075<li><code>(warn MESSAGE)</code> allows you to specify a warning object, usually
     1076a string, that gets associated with the expectation. The <code>warn</code>
     1077function name is actually a syntax reserved word in the macro.</li>
     1078
     1079<li><code>KIND</code> is a string stating the kind of test.</li>
     1080
    11101081<li><code>PREDICATE</code> is a procedure of two arguments to perform the
    11111082test.</li>
     
    11201091</dd>
    11211092
    1122 <dt><em>(macro)</em><code> expect-zero</code></dt>
    1123 <dd><br />
    1124 (expect-zero [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1125 <br /></dd>
     1093<dt>[<em>syntax</em>] <code>expect-zero</code></dt>
     1094<dd><br/>(expect-zero [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    11261095<dd>
    11271096<ul>
     
    11391108</dd>
    11401109
    1141 <dt><em>(macro)</em><code> expect-nonzero</code></dt>
    1142 <dd><br />
    1143 (expect-nonzero [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1144 <br /></dd>
     1110<dt>[<em>syntax</em>] <code>expect-nonzero</code></dt>
     1111<dd><br/>(expect-nonzero [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    11451112<dd>
    11461113<ul>
     
    11581125</dd>
    11591126
    1160 <dt><em>(macro)</em><code> expect-positive</code></dt>
    1161 <dd><br />
    1162 (expect-positive [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1163 <br /></dd>
     1127<dt>[<em>syntax</em>] <code>expect-positive</code></dt>
     1128<dd><br/>(expect-positive [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    11641129<dd>
    11651130<ul>
     
    11771142</dd>
    11781143
    1179 <dt><em>(macro)</em><code> expect-negative</code></dt>
    1180 <dd><br />
    1181 (expect-negative [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1182 <br /></dd>
     1144<dt>[<em>syntax</em>] <code>expect-negative</code></dt>
     1145<dd><br/>(expect-negative [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    11831146<dd>
    11841147<ul>
     
    11961159</dd>
    11971160
    1198 <dt><em>(macro)</em><code> expect-near</code></dt>
    1199 <dd><br />
    1200 (expect-near [TEST-NAME] [(warn MESSAGE)] EXPECTED [TOL] EXPRESSION)
    1201 <br /></dd>
     1161<dt>[<em>syntax</em>] <code>expect-near</code></dt>
     1162<dd><br/>(expect-near [TEST-NAME] [(warn MESSAGE)] EXPECTED [TOL] EXPRESSION)<br/></dd>
    12021163<dd>
    12031164<ul>
     
    12261187</dd>
    12271188
    1228 <dt><em>(macro)</em><code> expect-true</code></dt>
    1229 <dd><br />
    1230 (expect-true [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1231 <br /></dd>
     1189<dt>[<em>syntax</em>] <code>expect-true</code></dt>
     1190<dd><br/>(expect-true [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    12321191<dd>
    12331192<ul>
     
    12451204</dd>
    12461205
    1247 <dt><em>(macro)</em><code> expect-false</code></dt>
    1248 <dd><br />
    1249 (expect-false [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1250 <br /></dd>
     1206<dt>[<em>syntax</em>] <code>expect-false</code></dt>
     1207<dd><br/>(expect-false [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    12511208<dd>
    12521209<ul>
     
    12641221</dd>
    12651222
    1266 <dt><em>(macro)</em><code> expect-success</code></dt>
    1267 <dd><br />
    1268 (expect-success [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1269 <br /></dd>
     1223<dt>[<em>syntax</em>] <code>expect-success</code></dt>
     1224<dd><br/>(expect-success [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    12701225<dd>
    12711226<ul>
     
    12841239</dd>
    12851240
    1286 <dt><em>(macro)</em><code> expect-failure</code></dt>
    1287 <dd><br />
    1288 (expect-failure [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1289 <br /></dd>
     1241<dt>[<em>syntax</em>] <code>expect-failure</code></dt>
     1242<dd><br/>(expect-failure [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    12901243<dd>
    12911244<ul>
     
    13041257</dd>
    13051258
    1306 <dt><em>(macro)</em><code> expect-not-false</code></dt>
    1307 <dd><br />
    1308 (expect-not-false [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1309 <br /></dd>
     1259<dt>[<em>syntax</em>] <code>expect-not-false</code></dt>
     1260<dd><br/>(expect-not-false [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    13101261<dd>
    13111262<ul>
     
    13241275</dd>
    13251276
    1326 <dt><em>(macro)</em><code> expect-not-null</code></dt>
    1327 <dd><br />
    1328 (expect-not-null [TEST-NAME] [(warn MESSAGE)] EXPRESSION)
    1329 <br /></dd>
     1277<dt>[<em>syntax</em>] <code>expect-not-null</code></dt>
     1278<dd><br/>(expect-not-null [TEST-NAME] [(warn MESSAGE)] EXPRESSION)<br/></dd>
    13301279<dd>
    13311280<ul>
     
    13441293</dd>
    13451294
    1346 <dt><em>(macro)</em><code> expect-eq</code></dt>
    1347 <dd><br />
    1348 (expect-eq [TEST-NAME] [(warn MESSAGE)] EXPECTED EXPRESSION)
    1349 <br /></dd>
     1295<dt>[<em>syntax</em>] <code>expect-eq</code></dt>
     1296<dd><br/>(expect-eq [TEST-NAME] [(warn MESSAGE)] EXPECTED EXPRESSION)<br/></dd>
    13501297<dd>
    13511298<ul>
     
    13671314expression is <code>#t</code>.</li>
    13681315
    1369 <li>The result object this macro produce shall contain the un-evaluated
    1370 <code>EXPRESSION</code> expression as a field, but not an un-evaluated
     1316<li>The result object this macro produce shall contain the unevaluated
     1317<code>EXPRESSION</code> expression as a field, but not an unevaluated
    13711318<code>EXPECTED</code> expression.</li>
    13721319</ul>
    13731320</dd>
    13741321
    1375 <dt><em>(macro)</em><code> expect-eqv</code></dt>
    1376 <dd><br />
    1377 (expect-eqv [TEST-NAME] [(warn MESSAGE)] EXPECTED EXPRESSION)
    1378 <br /></dd>
     1322<dt>[<em>syntax</em>] <code>expect-eqv</code></dt>
     1323<dd><br/>(expect-eqv [TEST-NAME] [(warn MESSAGE)] EXPECTED EXPRESSION)<br/></dd>
    13791324<dd>
    13801325<ul>
     
    13961341expression is <code>#t</code>.</li>
    13971342
    1398 <li>The result object this macro produce shall contain the un-evaluated
    1399 <code>EXPRESSION</code> expression as a field, but not an un-evaluated
     1343<li>The result object this macro produce shall contain the unevaluated
     1344<code>EXPRESSION</code> expression as a field, but not an unevaluated
    14001345<code>EXPECTED</code> expression.</li>
    14011346</ul>
    14021347</dd>
    14031348
    1404 <dt><em>(macro)</em><code> expect-equal</code></dt>
    1405 <dd><br />
    1406 (expect-equal [TEST-NAME] [(warn MESSAGE)] EXPECTED EXPRESSION)
    1407 <br /></dd>
     1349<dt>[<em>syntax</em>] <code>expect-equal</code></dt>
     1350<dd><br/>(expect-equal [TEST-NAME] [(warn MESSAGE)] EXPECTED EXPRESSION)<br/></dd>
    14081351<dd>
    14091352<ul>
     
    14251368expression is <code>#t</code>.</li>
    14261369
    1427 <li>The result object this macro produce shall contain the un-evaluated
    1428 <code>EXPRESSION</code> expression as a field, but not an un-evaluated
     1370<li>The result object this macro produce shall contain the unevaluated
     1371<code>EXPRESSION</code> expression as a field, but not an unevaluated
    14291372<code>EXPECTED</code> expression.</li>
    14301373</ul>
    14311374</dd>
    14321375
    1433 <dt><em>(macro)</em><code> expect-unary/values</code></dt>
    1434 <dd><br />
    1435 (expect-unary/values [TEST-NAME] [(warn MESSAGE)] KIND (PREDICATE ...) EXPRESSION)
    1436 <br /></dd>
     1376<dt>[<em>syntax</em>] <code>expect-unary/values</code></dt>
     1377<dd><br/>(expect-unary/values [TEST-NAME] [(warn MESSAGE)] KIND (PREDICATE ...) EXPRESSION)<br/></dd>
    14371378<dd>
    14381379<ul>
     
    14561397</dd>
    14571398
    1458 <dt><em>(macro)</em><code> expect-binary/values</code></dt>
    1459 <dd><br />
    1460 (expect-binary/values [TEST-NAME] [(warn MESSAGE)] KIND (PREDICATE ...) VALUES EXPRESSION)
    1461 <br /></dd>
     1399<dt>[<em>syntax</em>] <code>expect-binary/values</code></dt>
     1400<dd><br/>(expect-binary/values [TEST-NAME] [(warn MESSAGE)] KIND (PREDICATE ...) VALUES EXPRESSION)<br/></dd>
    14621401<dd>
    14631402<ul>
     
    14831422</dd>
    14841423
    1485 <dt><em>(macro)</em><code> expect-near/values</code></dt>
    1486 <dd><br />
    1487 (expect-near/values [TEST-NAME] [(warn MESSAGE)] EXPECTED [TOL] EXPRESSION)
    1488 <br /></dd>
     1424<dt>[<em>syntax</em>] <code>expect-near/values</code></dt>
     1425<dd><br/>(expect-near/values [TEST-NAME] [(warn MESSAGE)] EXPECTED [TOL] EXPRESSION)<br/></dd>
    14891426<dd>
    14901427<ul>
     
    15141451</dd>
    15151452
    1516 <dt><em>(macro)</em><code> expect-eq/values</code></dt>
    1517 <dd><br />
    1518 (expect-eq/values [TEST-NAME] [(warn MESSAGE)] VALUES EXPRESSION)
    1519 <br /></dd>
     1453<dt>[<em>syntax</em>] <code>expect-eq/values</code></dt>
     1454<dd><br/>(expect-eq/values [TEST-NAME] [(warn MESSAGE)] VALUES EXPRESSION)<br/></dd>
    15201455<dd>
    15211456<ul>
     
    15361471</dd>
    15371472
    1538 <dt><em>(macro)</em><code> expect-eqv/values</code></dt>
    1539 <dd><br />
    1540 (expect-eqv/values [TEST-NAME] [(warn MESSAGE)] VALUES EXPRESSION)
    1541 <br /></dd>
     1473<dt>[<em>syntax</em>] <code>expect-eqv/values</code></dt>
     1474<dd><br/>(expect-eqv/values [TEST-NAME] [(warn MESSAGE)] VALUES EXPRESSION)<br/></dd>
    15421475<dd>
    15431476<ul>
     
    15581491</dd>
    15591492
    1560 <dt><em>(macro)</em><code> expect-equal/values</code></dt>
    1561 <dd><br />
    1562 (expect-equal/values [TEST-NAME] [(warn MESSAGE)] VALUES EXPRESSION)
    1563 <br /></dd>
     1493<dt>[<em>syntax</em>] <code>expect-equal/values</code></dt>
     1494<dd><br/>(expect-equal/values [TEST-NAME] [(warn MESSAGE)] VALUES EXPRESSION)<br/></dd>
    15641495<dd>
    15651496<ul>
     
    15801511</dd>
    15811512
    1582 <dt><em>(macro)</em><code> expect-exception</code></dt>
    1583 <dd><br />
    1584 (expect-exception [TEST-NAME] [(warn MESSAGE)] EXCEPTION-PATTERN EXPRESSION)
    1585 <br /></dd>
     1513<dt>[<em>syntax</em>] <code>expect-exception</code></dt>
     1514<dd><br/>(expect-exception [TEST-NAME] [(warn MESSAGE)] EXCEPTION-PATTERN EXPRESSION)<br/></dd>
    15861515<dd>
    15871516<ul>
     
    16471576</dd>
    16481577
    1649 <dt><em>(macro)</em><code> expect-ec</code></dt>
    1650 <dd><br />
    1651 (expect-ec [TEST-NAME] [(warn MESSAGE)] QUALIFIER ... EXPECTED [=&gt; PREDICATE] EXPRESSION)
    1652 <br /></dd>
     1578<dt>[<em>syntax</em>] <code>expect-ec</code></dt>
     1579<dd><br/>(expect-ec [TEST-NAME] [(warn MESSAGE)] QUALIFIER ... EXPECTED [=&gt; PREDICATE] EXPRESSION)<br/></dd>
    16531580<dd>
    16541581<ul>
     
    16751602</dd>
    16761603
    1677 <dt><em>(macro)</em><code> expect-set!</code></dt>
    1678 <dd><br />
    1679 (expect-set! [TEST-NAME] VARIABLE VALUE)
    1680 <br /></dd>
     1604<dt>[<em>syntax</em>] <code>expect-set!</code></dt>
     1605<dd><br/>(expect-set! [TEST-NAME] VARIABLE VALUE)<br/></dd>
    16811606<dd>
    16821607<ul>
     
    17001625<dl>
    17011626
    1702 <dt><em>(syntax)</em><code> define-expect-unary</code></dt>
    1703 <dd><br />
    1704 (define-expect-unary PREDICATE [SUFFIX [KIND]])
    1705 <br /></dd>
     1627<dt>[<em>syntax</em>] <code>define-expect-unary</code></dt>
     1628<dd><br/>(define-expect-unary PREDICATE [SUFFIX [KIND]])<br/></dd>
    17061629<dd>
    17071630<ul>
     
    17201643</dd>
    17211644
    1722 <dt><em>(syntax)</em><code> define-expect-binary</code></dt>
    1723 <dd><br />
    1724 (define-expect-binary PREDICATE [SUFFIX [KIND]])
    1725 <br /></dd>
     1645<dt>[<em>syntax</em>] <code>define-expect-binary</code></dt>
     1646<dd><br/>(define-expect-binary PREDICATE [SUFFIX [KIND]])<br/></dd>
    17261647<dd>
    17271648<ul>
     
    17401661</dd>
    17411662
    1742 <dt><em>(syntax)</em><code> define-expect-unary/values</code></dt>
    1743 <dd><br />
    1744 (define-expect-unary/values PREDICATE [SUFFIX [KIND]])
    1745 <br /></dd>
     1663<dt>[<em>syntax</em>] <code>define-expect-unary/values</code></dt>
     1664<dd><br/>(define-expect-unary/values PREDICATE [SUFFIX [KIND]])<br/></dd>
    17461665<dd>
    17471666<ul>
     
    17601679</dd>
    17611680
    1762 <dt><em>(syntax)</em><code> define-expect-binary/values</code></dt>
    1763 <dd><br />
    1764 (define-expect-binary/values PREDICATE [SUFFIX [KIND]])
    1765 <br /></dd>
     1681<dt>[<em>syntax</em>] <code>define-expect-binary/values</code></dt>
     1682<dd><br/>(define-expect-binary/values PREDICATE [SUFFIX [KIND]])<br/></dd>
    17661683<dd>
    17671684<ul>
     
    17801697</dd>
    17811698
    1782 <dt><em>(syntax)</em><code> define-expect-nary</code></dt>
    1783 <dd><br />
    1784 (define-expect-nary (SUFFIX ARG ...) EXPR ...)
    1785 <br /></dd>
     1699<dt>[<em>syntax</em>] <code>define-expect-nary</code></dt>
     1700<dd><br/>(define-expect-nary (SUFFIX ARG ...) EXPR ...)<br/></dd>
    17861701<dd>
    17871702<ul>
     
    18131728<dl>
    18141729
    1815 <dt><em>(macro)</em><code> test-eval</code></dt>
    1816 <dd><br />
     1730<dt>[<em>syntax</em>] <code>test-eval</code></dt>
     1731<dd><br/>
    18171732(test-eval [TEST-NAME] EXPRESSION)
    1818 <br /><br /></dd>
    1819 
    1820 <dt><em>(macro)</em><code> test/eq</code></dt>
    1821 <dd><br />
     1733<br/><br/></dd>
     1734
     1735<dt>[<em>syntax</em>] <code>test/eq</code></dt>
     1736<dd><br/>
    18221737(test/eq [TEST-NAME] EXPRESSION EXPECTED)
    1823 <br /><br /></dd>
    1824 
    1825 <dt><em>(macro)</em><code> test/eqv</code></dt>
    1826 <dd><br />
     1738<br/><br/></dd>
     1739
     1740<dt>[<em>syntax</em>] <code>test/eqv</code></dt>
     1741<dd><br/>
    18271742(test/eqv [TEST-NAME] EXPRESSION EXPECTED)
    1828 <br /><br /></dd>
    1829 
    1830 <dt><em>(macro)</em><code> test/equal</code></dt>
    1831 <dd><br />
     1743<br/><br/></dd>
     1744
     1745<dt>[<em>syntax</em>] <code>test/equal</code></dt>
     1746<dd><br/>
    18321747(test/equal [TEST-NAME] EXPRESSION EXPECTED)
    1833 <br /><br /></dd>
     1748<br/><br/></dd>
    18341749
    18351750</dl>
     
    18411756
    18421757<dl>
    1843 <dt><em>(macro)</em><code> side-effect</code></dt>
    1844 <dd><br />
    1845 (side-effect CLAUSES)
    1846 <br /></dd>
     1758<dt>[<em>syntax</em>] <code>side-effect</code></dt>
     1759<dd><br/>(side-effect CLAUSES)<br/></dd>
    18471760<dd>
    18481761<ul>
     
    18611774
    18621775<dl>
    1863 <dt><em>(macro)</em><code> setup</code></dt>
    1864 <dd><br />
    1865 (setup CLAUSES)
    1866 <br /></dd>
     1776<dt>[<em>syntax</em>] <code>setup</code></dt>
     1777<dd><br/>(setup CLAUSES)<br/></dd>
    18671778<dd>
    18681779<ul>
     
    18861797
    18871798<dl>
    1888 <dt><em>(macro)</em><code> destructor-atexit!</code></dt>
    1889 <dd><br />
     1799<dt>[<em>syntax</em>] <code>destructor-atexit!</code></dt>
     1800<dd><br/>
    18901801(destructor-atexit! [DTOR-NAME] CALL ...)
    1891 <br />
     1802<br/>
    18921803(destructor-atexit! DTOR-NAME PROC ARGUMENT ...)
    1893 <br /></dd>
     1804<br/></dd>
    18941805<dd>
    18951806<ul>
     
    19231834
    19241835<dl>
    1925 <dt><em>(macro)</em><code> teardown</code></dt>
    1926 <dd><br />
    1927 (teardown [DTOR-NAME] (FUNC ARGUMENT ...) ...)
    1928 <br /></dd>
     1836<dt>[<em>syntax</em>] <code>teardown</code></dt>
     1837<dd><br/>(teardown [DTOR-NAME] (FUNC ARGUMENT ...) ...)<br/></dd>
    19291838<dd><ul>
    19301839<li>A <code>(FUNC ARGUMENT ...)</code> for is also refered to as a <code>CALL</code>.</li>
     
    19361845
    19371846<dl>
    1938 <dt><em>(macro)</em><code> destructor-activate!</code></dt>
    1939 <dd><br />
    1940 (destructor-activate! [DTOR-NAME])
    1941 <br /></dd>
     1847<dt>[<em>syntax</em>] <code>destructor-activate!</code></dt>
     1848<dd><br/>(destructor-activate! [DTOR-NAME])<br/></dd>
    19421849<dd>
    19431850<ul>
     
    19571864
    19581865<dl>
    1959 <dt><em>(macro)</em><code> destructor-clear!</code></dt>
    1960 <dd><br />
    1961 (destructor-clear! [DTOR-NAME])
    1962 <br /></dd>
     1866<dt>[<em>syntax</em>] <code>destructor-clear!</code></dt>
     1867<dd><br/>(destructor-clear! [DTOR-NAME])<br/></dd>
    19631868<dd>
    19641869<ul>
     
    19761881
    19771882<dl>
    1978 <dt><em>(macro)</em><code> destructor-dump</code></dt>
    1979 <dd><br />
    1980 (destructor-dump [DTOR-NAME])
    1981 <br /></dd>
     1883<dt>[<em>syntax</em>] <code>destructor-dump</code></dt>
     1884<dd><br/>(destructor-dump [DTOR-NAME])<br/></dd>
    19821885<dd>
    19831886<ul>
     
    20001903
    20011904<dl>
    2002 <dt><em>(macro)</em><code> gloss</code></dt>
    2003 <dd><br />
    2004 (gloss [(warn WARNING)] MESSAGE)
    2005 <br /></dd>
     1905<dt>[<em>syntax</em>] <code>gloss</code></dt>
     1906<dd><br/>(gloss [(warn WARNING)] MESSAGE)<br/></dd>
    20061907<dd><ul>
    20071908<li><code>MESSAGE</code> can be any scheme object, though usually it is a
     
    20221923
    20231924<dl>
    2024 <dt><em>(macro)</em><code> skip</code></dt>
    2025 <dd><br />
    2026 (skip [(warn WARNING)] MESSAGE CLAUSES)
    2027 <br /></dd>
     1925<dt>[<em>syntax</em>] <code>skip</code></dt>
     1926<dd><br/>(skip [(warn WARNING)] MESSAGE CLAUSES)<br/></dd>
    20281927<dd><ul>
    20291928<li><code>MESSAGE</code> can be any scheme object, though usually it is a
     
    20451944
    20461945<dl>
    2047 <dt><em>(macro)</em><code> terminate</code></dt>
    2048 <dd><br />
     1946<dt>[<em>syntax</em>] <code>terminate</code></dt>
     1947<dd><br/>
    20491948(terminate MESSAGE)
    20501949(terminate MESSAGE FINDING)
    20511950(terminate ESCR-NAME MESSAGE)
    20521951(terminate ESCR-NAME MESSAGE FINDING)
    2053 <br /></dd>
     1952<br/></dd>
    20541953<dd>
    20551954<ul>
     
    20741973
    20751974<dl>
    2076 <dt><em>(macro)</em><code> todo</code></dt>
    2077 <dd><br />
    2078 (todo [(warn WARNING)] MESSAGE)
    2079 <br /></dd>
     1975<dt>[<em>syntax</em>] <code>todo</code></dt>
     1976<dd><br/>(todo [(warn WARNING)] MESSAGE)<br/></dd>
    20801977<dd><ul>
    20811978<li><code>MESSAGE</code> can be any scheme object, though usually it is a
     
    21072004
    21082005<dl>
    2109 <dt><em>(procedure)</em><code> test::result?</code></dt>
    2110 <dd><br />
    2111 (test::result? RESULT-OBJ)
    2112 <br /></dd>
     2006<dt>[<em>procedure</em>] <code>test::result?</code></dt>
     2007<dd><br/>(test::result? RESULT-OBJ)<br/></dd>
    21132008<dd>
    21142009<ul>
     
    21212016
    21222017<dl>
    2123 <dt><em>(procedure)</em><code> test::ignore-result?</code></dt>
    2124 <dd><br />
    2125 (test::ignore-result? RESULT-OBJ)
    2126 <br /></dd>
     2018<dt>[<em>procedure</em>] <code>test::ignore-result?</code></dt>
     2019<dd><br/>(test::ignore-result? RESULT-OBJ)<br/></dd>
    21272020<dd>
    21282021<ul>
     
    21352028
    21362029<dl>
    2137 <dt><em>(procedure)</em><code> test::result-passed?</code></dt>
    2138 <dd><br />
    2139 (test::result-passed? RESULT-OBJ)
    2140 <br /></dd>
     2030<dt>[<em>procedure</em>] <code>test::result-passed?</code></dt>
     2031<dd><br/>(test::result-passed? RESULT-OBJ)<br/></dd>
    21412032<dd>
    21422033<ul>
     
    21492040
    21502041<dl>
    2151 <dt><em>(procedure)</em><code> test::result-finding</code></dt>
    2152 <dd><br />
    2153 (test::result-finding RESULT-OBJ)
    2154 <br /></dd>
     2042<dt>[<em>procedure</em>] <code>test::result-finding</code></dt>
     2043<dd><br/>(test::result-finding RESULT-OBJ)<br/></dd>
    21552044<dd>
    21562045<ul>
     
    21652054
    21662055<dl>
    2167 <dt><em>(procedure)</em><code> test::result-name</code></dt>
    2168 <dd><br />
    2169 (test::result-name RESULT-OBJ)
    2170 <br /></dd>
     2056<dt>[<em>procedure</em>] <code>test::result-name</code></dt>
     2057<dd><br/>(test::result-name RESULT-OBJ)<br/></dd>
    21712058<dd>
    21722059<ul>
     
    21782065
    21792066<dl>
    2180 <dt><em>(procedure)</em><code> test::result-message</code></dt>
    2181 <dd><br />
    2182 (test::result-message RESULT-OBJ)
    2183 <br /></dd>
     2067<dt>[<em>procedure</em>] <code>test::result-message</code></dt>
     2068<dd><br/>(test::result-message RESULT-OBJ)<br/></dd>
    21842069<dd>
    21852070<ul>
     
    21912076
    21922077<dl>
    2193 <dt><em>(procedure)</em><code> test::result-warning?</code></dt>
    2194 <dd><br />
    2195 (test::result-warning? RESULT-OBJ)
    2196 <br /></dd>
     2078<dt>[<em>procedure</em>] <code>test::result-warning?</code></dt>
     2079<dd><br/>(test::result-warning? RESULT-OBJ)<br/></dd>
    21972080<dd>
    21982081<ul>
     
    22042087
    22052088<dl>
    2206 <dt><em>(procedure)</em><code> test::result-warning</code></dt>
    2207 <dd><br />
    2208 (test::result-warning RESULT-OBJ)
    2209 <br /></dd>
     2089<dt>[<em>procedure</em>] <code>test::result-warning</code></dt>
     2090<dd><br/>(test::result-warning RESULT-OBJ)<br/></dd>
    22102091<dd>
    22112092<ul>
     
    22172098
    22182099<dl>
    2219 <dt><em>(procedure)</em><code> test::result-timing?</code></dt>
    2220 <dd><br />
    2221 (test::result-timing? RESULT-OBJ)
    2222 <br /></dd>
     2100<dt>[<em>procedure</em>] <code>test::result-timing?</code></dt>
     2101<dd><br/>(test::result-timing? RESULT-OBJ)<br/></dd>
    22232102<dd>
    22242103<ul>
     
    22302109
    22312110<dl>
    2232 <dt><em>(procedure)</em><code> test::result-timing</code></dt>
    2233 <dd><br />
    2234 (test::result-timing RESULT-OBJ)
    2235 <br /></dd>
     2111<dt>[<em>procedure</em>] <code>test::result-timing</code></dt>
     2112<dd><br/>(test::result-timing RESULT-OBJ)<br/></dd>
    22362113<dd>
    22372114<ul>
     
    22492126
    22502127<dl>
    2251 <dt><em>(procedure)</em><code> test::result-timing-message</code></dt>
    2252 <dd><br />
    2253 (test::result-timing-message RESULT-OBJ)
    2254 <br /></dd>
     2128<dt>[<em>procedure</em>] <code>test::result-timing-message</code></dt>
     2129<dd><br/>(test::result-timing-message RESULT-OBJ)<br/></dd>
    22552130<dd>
    22562131<ul>
     
    22622137
    22632138<dl>
    2264 <dt><em>(procedure)</em><code> test::result-kind</code></dt>
    2265 <dd><br />
    2266 (test::result-kind RESULT-OBJ)
    2267 <br /></dd>
     2139<dt>[<em>procedure</em>] <code>test::result-kind</code></dt>
     2140<dd><br/>(test::result-kind RESULT-OBJ)<br/></dd>
    22682141<dd>
    22692142<ul>
     
    22852158
    22862159<dl>
    2287 <dt><em>(procedure)</em><code> test::test-suite-result?</code></dt>
    2288 <dd><br />
    2289 (test::test-suite-result? RESULT)
    2290 <br /></dd>
     2160<dt>[<em>procedure</em>] <code>test::test-suite-result?</code></dt>
     2161<dd><br/>(test::test-suite-result? RESULT)<br/></dd>
    22912162<dd>
    22922163<ul>
     
    22992170
    23002171<dl>
    2301 <dt><em>(procedure)</em><code> test::test-suite-result-passed?</code></dt>
    2302 <dd><br />
    2303 (test::test-suite-result-passed? RESULT)
    2304 <br /></dd>
     2172<dt>[<em>procedure</em>] <code>test::test-suite-result-passed?</code></dt>
     2173<dd><br/>(test::test-suite-result-passed? RESULT)<br/></dd>
    23052174<dd>
    23062175<ul>
     
    23122181
    23132182<dl>
    2314 <dt><em>(procedure)</em><code> test::test-suite-result-finding</code></dt>
    2315 <dd><br />
    2316 (test::test-suite-result-finding RESULT)
    2317 <br /></dd>
     2183<dt>[<em>procedure</em>] <code>test::test-suite-result-finding</code></dt>
     2184<dd><br/>(test::test-suite-result-finding RESULT)<br/></dd>
    23182185<dd>
    23192186<ul>
     
    23242191
    23252192<dl>
    2326 <dt><em>(procedure)</em><code> test::test-suite-result-name</code></dt>
    2327 <dd><br />
    2328 (test::test-suite-result-name RESULT)
    2329 <br /></dd>
     2193<dt>[<em>procedure</em>] <code>test::test-suite-result-name</code></dt>
     2194<dd><br/>(test::test-suite-result-name RESULT)<br/></dd>
    23302195<dd>
    23312196<ul>
     
    23362201
    23372202<dl>
    2338 <dt><em>(procedure)</em><code> test::test-suite-result-list</code></dt>
    2339 <dd><br />
    2340 (test::test-suite-result-list RESULT)
    2341 <br /></dd>
     2203<dt>[<em>procedure</em>] <code>test::test-suite-result-list</code></dt>
     2204<dd><br/>(test::test-suite-result-list RESULT)<br/></dd>
    23422205<dd>
    23432206<ul>
     
    23492212
    23502213<dl>
    2351 <dt><em>(procedure)</em><code> test::test-suite-result-warning?</code></dt>
    2352 <dd><br />
    2353 (test::test-suite-result-warning? RESULT)
    2354 <br /></dd>
     2214<dt>[<em>procedure</em>] <code>test::test-suite-result-warning?</code></dt>
     2215<dd><br/>(test::test-suite-result-warning? RESULT)<br/></dd>
    23552216<dd>
    23562217<ul>
     
    23622223
    23632224<dl>
    2364 <dt><em>(procedure)</em><code> test::test-suite-result-warning</code></dt>
    2365 <dd><br />
    2366 (test::test-suite-result-warning RESULT)
    2367 <br /></dd>
     2225<dt>[<em>procedure</em>] <code>test::test-suite-result-warning</code></dt>
     2226<dd><br/>(test::test-suite-result-warning RESULT)<br/></dd>
    23682227<dd>
    23692228<ul>
     
    23762235
    23772236<dl>
    2378 <dt><em>(procedure)</em><code> test::test-suite-result-timing?</code></dt>
    2379 <dd><br />
    2380 (test::test-suite-result-timing? RESULT)
    2381 <br /></dd>
     2237<dt>[<em>procedure</em>] <code>test::test-suite-result-timing?</code></dt>
     2238<dd><br/>(test::test-suite-result-timing? RESULT)<br/></dd>
    23822239<dd>
    23832240<ul>
     
    23892246
    23902247<dl>
    2391 <dt><em>(procedure)</em><code> test::test-suite-result-timing</code></dt>
    2392 <dd><br />
    2393 (test::test-suite-result-timing RESULT)
    2394 <br /></dd>
     2248<dt>[<em>procedure</em>] <code>test::test-suite-result-timing</code></dt>
     2249<dd><br/>(test::test-suite-result-timing RESULT)<br/></dd>
    23952250<dd>
    23962251<ul>
     
    24022257
    24032258<dl>
    2404 <dt><em>(procedure)</em><code> test::test-suite-results-passed?</code></dt>
    2405 <dd><br />
    2406 (test::test-suite-results-passed? RESULT-LIST)
    2407 <br /></dd>
     2259<dt>[<em>procedure</em>] <code>test::test-suite-results-passed?</code></dt>
     2260<dd><br/>(test::test-suite-results-passed? RESULT-LIST)<br/></dd>
    24082261<dd>
    24092262<ul>
     
    24222275
    24232276<dl>
    2424 <dt><em>(procedure)</em><code> test::test-case-result?</code></dt>
    2425 <dd><br />
    2426 (test::test-case-result? RESULT)
    2427 <br /></dd>
     2277<dt>[<em>procedure</em>] <code>test::test-case-result?</code></dt>
     2278<dd><br/>(test::test-case-result? RESULT)<br/></dd>
    24282279<dd>
    24292280<ul>
     
    24362287
    24372288<dl>
    2438 <dt><em>(procedure)</em><code> test::test-case-result-passed?</code></dt>
    2439 <dd><br />
    2440 (test::test-case-result-passed? RESULT)
    2441 <br /></dd>
     2289<dt>[<em>procedure</em>] <code>test::test-case-result-passed?</code></dt>
     2290<dd><br/>(test::test-case-result-passed? RESULT)<br/></dd>
    24422291<dd>
    24432292<ul>
     
    24482297
    24492298<dl>
    2450 <dt><em>(procedure)</em><code> test::test-case-result-finding</code></dt>
    2451 <dd><br />
    2452 (test::test-case-result-finding RESULT)
    2453 <br /></dd>
     2299<dt>[<em>procedure</em>] <code>test::test-case-result-finding</code></dt>
     2300<dd><br/>(test::test-case-result-finding RESULT)<br/></dd>
    24542301<dd>
    24552302<ul>
     
    24602307
    24612308<dl>
    2462 <dt><em>(procedure)</em><code> test::test-case-result-name</code></dt>
    2463 <dd><br />
    2464 (test::test-case-result-name RESULT)
    2465 <br /></dd>
     2309<dt>[<em>procedure</em>] <code>test::test-case-result-name</code></dt>
     2310<dd><br/>(test::test-case-result-name RESULT)<br/></dd>
    24662311<dd>
    24672312<ul>
     
    24722317
    24732318<dl>
    2474 <dt><em>(procedure)</em><code> test::test-case-result-list</code></dt>
    2475 <dd><br />
    2476 (test::test-case-result-list RESULT)
    2477 <br /></dd>
     2319<dt>[<em>procedure</em>] <code>test::test-case-result-list</code></dt>
     2320<dd><br/>(test::test-case-result-list RESULT)<br/></dd>
    24782321<dd>
    24792322<ul>
     
    24852328
    24862329<dl>
    2487 <dt><em>(procedure)</em><code> test::test-case-result-warning?</code></dt>
    2488 <dd><br />
    2489 (test::test-case-result-warning? RESULT)
    2490 <br /></dd>
     2330<dt>[<em>procedure</em>] <code>test::test-case-result-warning?</code></dt>
     2331<dd><br/>(test::test-case-result-warning? RESULT)<br/></dd>
    24912332<dd>
    24922333<ul>
     
    24982339
    24992340<dl>
    2500 <dt><em>(procedure)</em><code> test::test-case-result-warning</code></dt>
    2501 <dd><br />
    2502 (test::test-case-result-warning RESULT)
    2503 <br /></dd>
     2341<dt>[<em>procedure</em>] <code>test::test-case-result-warning</code></dt>
     2342<dd><br/>(test::test-case-result-warning RESULT)<br/></dd>
    25042343<dd>
    25052344<ul>
     
    25122351
    25132352<dl>
    2514 <dt><em>(procedure)</em><code> test::test-case-result-timing?</code></dt>
    2515 <dd><br />
    2516 (test::test-case-result-timing? RESULT)
    2517 <br /></dd>
     2353<dt>[<em>procedure</em>] <code>test::test-case-result-timing?</code></dt>
     2354<dd><br/>(test::test-case-result-timing? RESULT)<br/></dd>
    25182355<dd>
    25192356<ul>
     
    25252362
    25262363<dl>
    2527 <dt><em>(procedure)</em><code> test::test-case-result-timing</code></dt>
    2528 <dd><br />
    2529 (test::test-case-result-timing RESULT)
    2530 <br /></dd>
     2364<dt>[<em>procedure</em>] <code>test::test-case-result-timing</code></dt>
     2365<dd><br/>(test::test-case-result-timing RESULT)<br/></dd>
    25312366<dd>
    25322367<ul>
     
    25382373
    25392374<dl>
    2540 <dt><em>(procedure)</em><code> test::test-case-results-passed?</code></dt>
    2541 <dd><br />
    2542 (test::test-case-results-passed? RESULT-LIST)
    2543 <br /></dd>
     2375<dt>[<em>procedure</em>] <code>test::test-case-results-passed?</code></dt>
     2376<dd><br/>(test::test-case-results-passed? RESULT-LIST)<br/></dd>
    25442377<dd>
    25452378<ul>
     
    25652398
    25662399<dl>
    2567 <dt><em>(procedure)</em><code> test::expect-result?</code></dt>
    2568 <dd><br />
    2569 (test::expect-result? RESULT)
    2570 <br /></dd>
     2400<dt>[<em>procedure</em>] <code>test::expect-result?</code></dt>
     2401<dd><br/>(test::expect-result? RESULT)<br/></dd>
    25712402<dd>
    25722403<ul>
     
    25792410
    25802411<dl>
    2581 <dt><em>(procedure)</em><code> test::expect-result-finding</code></dt>
    2582 <dd><br />
    2583 (test::expect-result-finding RESULT)
    2584 <br /></dd>
     2412<dt>[<em>procedure</em>] <code>test::expect-result-finding</code></dt>
     2413<dd><br/>(test::expect-result-finding RESULT)<br/></dd>
    25852414<dd>
    25862415<ul>
     
    25922421
    25932422<dl>
    2594 <dt><em>(procedure)</em><code> test::expect-result-kind</code></dt>
    2595 <dd><br />
    2596 (test::expect-result-kind RESULT)
    2597 <br /></dd>
     2423<dt>[<em>procedure</em>] <code>test::expect-result-kind</code></dt>
     2424<dd><br/>(test::expect-result-kind RESULT)<br/></dd>
    25982425<dd>
    25992426<ul>
     
    26042431table describing what the "kind" fields are for each kind of single clause
    26052432style expectation:
    2606 <br /><br />
     2433<br/><br/>
    26072434<table border="1">
    26082435<tr><th>Unary Expectation</th><th>Associated Specific String</th></tr>
     
    26232450
    26242451<dl>
    2625 <dt><em>(procedure)</em><code> test::expect-result-name</code></dt>
    2626 <dd><br />
    2627 (test::expect-result-name RESULT)
    2628 <br /></dd>
     2452<dt>[<em>procedure</em>] <code>test::expect-result-name</code></dt>
     2453<dd><br/>(test::expect-result-name RESULT)<br/></dd>
    26292454<dd>
    26302455<ul>
     
    26362461
    26372462<dl>
    2638 <dt><em>(procedure)</em><code> test::expect-result-unevaled</code></dt>
    2639 <dd><br />
    2640 (test::expect-result-unevaled RESULT)
    2641 <br /></dd>
    2642 <dd>
    2643 <ul>
    2644 <li>Returns the un-evaluated expression supplied to a single clause style
     2463<dt>[<em>procedure</em>] <code>test::expect-result-unevaled</code></dt>
     2464<dd><br/>(test::expect-result-unevaled RESULT)<br/></dd>
     2465<dd>
     2466<ul>
     2467<li>Returns the unevaluated expression supplied to a single clause style
    26452468expectation macro.</li>
    26462469</ul>
     
    26492472
    26502473<dl>
    2651 <dt><em>(procedure)</em><code> test::expect-result-evaled</code></dt>
    2652 <dd><br />
    2653 (test::expect-result-evaled RESULT)
    2654 <br /></dd>
     2474<dt>[<em>procedure</em>] <code>test::expect-result-evaled</code></dt>
     2475<dd><br/>(test::expect-result-evaled RESULT)<br/></dd>
    26552476<dd>
    26562477<ul>
     
    26612482
    26622483<dl>
    2663 <dt><em>(procedure)</em><code> test::expect-result-warning?</code></dt>
    2664 <dd><br />
    2665 (test::expect-result-warning? RESULT)
    2666 <br /></dd>
     2484<dt>[<em>procedure</em>] <code>test::expect-result-warning?</code></dt>
     2485<dd><br/>(test::expect-result-warning? RESULT)<br/></dd>
    26672486<dd>
    26682487<ul>
     
    26742493
    26752494<dl>
    2676 <dt><em>(procedure)</em><code> test::expect-result-warning</code></dt>
    2677 <dd><br />
    2678 (test::expect-result-warning RESULT)
    2679 <br /></dd>
     2495<dt>[<em>procedure</em>] <code>test::expect-result-warning</code></dt>
     2496<dd><br/>(test::expect-result-warning RESULT)<br/></dd>
    26802497<dd>
    26812498<ul>
     
    26882505
    26892506<dl>
    2690 <dt><em>(procedure)</em><code> test::expect-result-timing?</code></dt>
    2691 <dd><br />
    2692 (test::expect-result-timing? RESULT)
    2693 <br /></dd>
     2507<dt>[<em>procedure</em>] <code>test::expect-result-timing?</code></dt>
     2508<dd><br/>(test::expect-result-timing? RESULT)<br/></dd>
    26942509<dd>
    26952510<ul>
     
    27012516
    27022517<dl>
    2703 <dt><em>(procedure)</em><code> test::expect-result-timing</code></dt>
    2704 <dd><br />
    2705 (test::expect-result-timing RESULT)
    2706 <br /></dd>
     2518<dt>[<em>procedure</em>] <code>test::expect-result-timing</code></dt>
     2519<dd><br/>(test::expect-result-timing RESULT)<br/></dd>
    27072520<dd>
    27082521<ul>
     
    27252538
    27262539<dl>
    2727 <dt><em>(procedure)</em><code> test::expect-equivalence-result?</code></dt>
    2728 <dd><br />
    2729 (test::expect-equivalence-result? RESULT)
    2730 <br /></dd>
     2540<dt>[<em>procedure</em>] <code>test::expect-equivalence-result?</code></dt>
     2541<dd><br/>(test::expect-equivalence-result? RESULT)<br/></dd>
    27312542<dd>
    27322543<ul>
     
    27392550
    27402551<dl>
    2741 <dt><em>(procedure)</em><code> test::expect-equivalence-result-finding</code></dt>
    2742 <dd><br />
    2743 (test::expect-equivalence-result-finding RESULT)
    2744 <br /></dd>
     2552<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-finding</code></dt>
     2553<dd><br/>(test::expect-equivalence-result-finding RESULT)<br/></dd>
    27452554<dd>
    27462555<ul>
     
    27522561
    27532562<dl>
    2754 <dt><em>(procedure)</em><code> test::expect-equivalence-result-kind</code></dt>
    2755 <dd><br />
    2756 (test::expect-equivalence-result-kind RESULT)
    2757 <br /></dd>
     2563<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-kind</code></dt>
     2564<dd><br/>(test::expect-equivalence-result-kind RESULT)<br/></dd>
    27582565<dd>
    27592566<ul>
     
    27642571Here is a table describing what the "kind" fields are for each kind of
    27652572equivalence style expectation:
    2766 <br /><br />
     2573<br/><br/>
    27672574<table border="1"><tr><th>Binary Expectation</th><th>Associated Specific String</th></tr>
    27682575<tr><td>expect-eq</td>                     <td>"eq"</td></tr>
     
    27822589
    27832590<dl>
    2784 <dt><em>(procedure)</em><code> test::expect-equivalence-result-name</code></dt>
    2785 <dd><br />
    2786 (test::expect-equivalence-result-name RESULT)
    2787 <br /></dd>
     2591<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-name</code></dt>
     2592<dd><br/>(test::expect-equivalence-result-name RESULT)<br/></dd>
    27882593<dd>
    27892594<ul>
     
    27952600
    27962601<dl>
    2797 <dt><em>(procedure)</em><code> test::expect-equivalence-result-lhs-evaled</code></dt>
    2798 <dd><br />
    2799 (test::expect-equivalence-result-lhs-evaled RESULT)
    2800 <br /></dd>
     2602<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-lhs-evaled</code></dt>
     2603<dd><br/>(test::expect-equivalence-result-lhs-evaled RESULT)<br/></dd>
    28012604<dd>
    28022605<ul>
     
    28082611
    28092612<dl>
    2810 <dt><em>(procedure)</em><code> test::expect-equivalence-result-rhs-unevaled</code></dt>
    2811 <dd><br />
    2812 (test::expect-equivalence-result-rhs-unevaled RESULT)
    2813 <br /></dd>
    2814 <dd>
    2815 <ul>
    2816 <li>Returns the un-evaluated "right hand side" expression supplied to an
     2613<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-rhs-unevaled</code></dt>
     2614<dd><br/>(test::expect-equivalence-result-rhs-unevaled RESULT)<br/></dd>
     2615<dd>
     2616<ul>
     2617<li>Returns the unevaluated "right hand side" expression supplied to an
    28172618equivalence style expectation.</li>
    28182619</ul>
     
    28212622
    28222623<dl>
    2823 <dt><em>(procedure)</em><code> test::expect-equivalence-result-rhs-evaled</code></dt>
    2824 <dd><br />
    2825 (test::expect-equivalence-result-rhs-evaled RESULT)
    2826 <br /></dd>
     2624<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-rhs-evaled</code></dt>
     2625<dd><br/>(test::expect-equivalence-result-rhs-evaled RESULT)<br/></dd>
    28272626<dd>
    28282627<ul>
     
    28342633
    28352634<dl>
    2836 <dt><em>(procedure)</em><code> test::expect-equivalence-result-warning?</code></dt>
    2837 <dd><br />
    2838 (test::expect-equivalence-result-warning? RESULT)
    2839 <br /></dd>
     2635<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-warning?</code></dt>
     2636<dd><br/>(test::expect-equivalence-result-warning? RESULT)<br/></dd>
    28402637<dd>
    28412638<ul>
     
    28472644
    28482645<dl>
    2849 <dt><em>(procedure)</em><code> test::expect-equivalence-result-warning</code></dt>
    2850 <dd><br />
    2851 (test::expect-equivalence-result-warning RESULT)
    2852 <br /></dd>
     2646<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-warning</code></dt>
     2647<dd><br/>(test::expect-equivalence-result-warning RESULT)<br/></dd>
    28532648<dd>
    28542649<ul>
     
    28612656
    28622657<dl>
    2863 <dt><em>(procedure)</em><code> test::expect-equivalence-result-timing?</code></dt>
    2864 <dd><br />
    2865 (test::expect-equivalence-result-timing? RESULT)
    2866 <br /></dd>
     2658<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-timing?</code></dt>
     2659<dd><br/>(test::expect-equivalence-result-timing? RESULT)<br/></dd>
    28672660<dd>
    28682661<ul>
     
    28742667
    28752668<dl>
    2876 <dt><em>(procedure)</em><code> test::expect-equivalence-result-timing</code></dt>
    2877 <dd><br />
    2878 (test::expect-equivalence-result-timing RESULT)
    2879 <br /></dd>
     2669<dt>[<em>procedure</em>] <code>test::expect-equivalence-result-timing</code></dt>
     2670<dd><br/>(test::expect-equivalence-result-timing RESULT)<br/></dd>
    28802671<dd>
    28812672<ul>
     
    28972688
    28982689<dl>
    2899 <dt><em>(procedure)</em><code> test::expect-tolerance-result?</code></dt>
    2900 <dd><br />
    2901 (test::expect-tolerance-result? RESULT)
    2902 <br /></dd>
     2690<dt>[<em>procedure</em>] <code>test::expect-tolerance-result?</code></dt>
     2691<dd><br/>(test::expect-tolerance-result? RESULT)<br/></dd>
    29032692<dd>
    29042693<ul>
     
    29112700
    29122701<dl>
    2913 <dt><em>(procedure)</em><code> test::expect-tolerance-result-finding</code></dt>
    2914 <dd><br />
    2915 (test::expect-tolerance-result-finding RESULT)
    2916 <br /></dd>
     2702<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-finding</code></dt>
     2703<dd><br/>(test::expect-tolerance-result-finding RESULT)<br/></dd>
    29172704<dd>
    29182705<ul>
     
    29242711
    29252712<dl>
    2926 <dt><em>(procedure)</em><code> test::expect-tolerance-result-kind</code></dt>
    2927 <dd><br />
    2928 (test::expect-tolerance-result-kind RESULT)
    2929 <br /></dd>
     2713<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-kind</code></dt>
     2714<dd><br/>(test::expect-tolerance-result-kind RESULT)<br/></dd>
    29302715<dd>
    29312716<ul>
     
    29362721<em>"near"</em>. Here is a table describing what the "kind" fields are for each
    29372722kind of tolerance style expectation:
    2938 <br /><br />
     2723<br/><br/>
    29392724<table border="1"><tr><th>Tolerance Style Expectation</th><th>Associated Specific String</th></tr>
    29402725<tr><td>expect-near</td>                 <td>"near"</td></tr>
     
    29452730
    29462731<dl>
    2947 <dt><em>(procedure)</em><code> test::expect-tolerance-result-name</code></dt>
    2948 <dd><br />
    2949 (test::expect-tolerance-result-name RESULT)
    2950 <br /></dd>
     2732<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-name</code></dt>
     2733<dd><br/>(test::expect-tolerance-result-name RESULT)<br/></dd>
    29512734<dd>
    29522735<ul>
     
    29582741
    29592742<dl>
    2960 <dt><em>(procedure)</em><code> test::expect-tolerance-result-lhs-evaled</code></dt>
    2961 <dd><br />
    2962 (test::expect-tolerance-result-lhs-evaled RESULT)
    2963 <br /></dd>
     2743<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-lhs-evaled</code></dt>
     2744<dd><br/>(test::expect-tolerance-result-lhs-evaled RESULT)<br/></dd>
    29642745<dd>
    29652746<ul>
     
    29712752
    29722753<dl>
    2973 <dt><em>(procedure)</em><code> test::expect-tolerance-result-lhs-tol-evaled</code></dt>
    2974 <dd><br />
    2975 (test::expect-tolerance-result-lhs-tol-evaled RESULT)
    2976 <br /></dd>
     2754<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-lhs-tol-evaled</code></dt>
     2755<dd><br/>(test::expect-tolerance-result-lhs-tol-evaled RESULT)<br/></dd>
    29772756<dd>
    29782757<ul>
     
    29842763
    29852764<dl>
    2986 <dt><em>(procedure)</em><code> test::expect-tolerance-result-rhs-unevaled</code></dt>
    2987 <dd><br />
    2988 (test::expect-tolerance-result-rhs-unevaled RESULT)
    2989 <br /></dd>
    2990 <dd>
    2991 <ul>
    2992 <li>Returns the un-evaluated "right hand side" expression supplied to a
     2765<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-rhs-unevaled</code></dt>
     2766<dd><br/>(test::expect-tolerance-result-rhs-unevaled RESULT)<br/></dd>
     2767<dd>
     2768<ul>
     2769<li>Returns the unevaluated "right hand side" expression supplied to a
    29932770tolerance style expectation.</li>
    29942771</ul>
     
    29972774
    29982775<dl>
    2999 <dt><em>(procedure)</em><code> test::expect-tolerance-result-rhs-evaled</code></dt>
    3000 <dd><br />
    3001 (test::expect-tolerance-result-rhs-evaled RESULT)
    3002 <br /></dd>
     2776<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-rhs-evaled</code></dt>
     2777<dd><br/>(test::expect-tolerance-result-rhs-evaled RESULT)<br/></dd>
    30032778<dd>
    30042779<ul>
     
    30102785
    30112786<dl>
    3012 <dt><em>(procedure)</em><code> test::expect-tolerance-result-warning?</code></dt>
    3013 <dd><br />
    3014 (test::expect-tolerance-result-warning? RESULT)
    3015 <br /></dd>
     2787<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-warning?</code></dt>
     2788<dd><br/>(test::expect-tolerance-result-warning? RESULT)<br/></dd>
    30162789<dd>
    30172790<ul>
     
    30232796
    30242797<dl>
    3025 <dt><em>(procedure)</em><code> test::expect-tolerance-result-warning</code></dt>
    3026 <dd><br />
    3027 (test::expect-tolerance-result-warning RESULT)
    3028 <br /></dd>
     2798<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-warning</code></dt>
     2799<dd><br/>(test::expect-tolerance-result-warning RESULT)<br/></dd>
    30292800<dd>
    30302801<ul>
     
    30372808
    30382809<dl>
    3039 <dt><em>(procedure)</em><code> test::expect-tolerance-result-timing?</code></dt>
    3040 <dd><br />
    3041 (test::expect-tolerance-result-timing? RESULT)
    3042 <br /></dd>
     2810<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-timing?</code></dt>
     2811<dd><br/>(test::expect-tolerance-result-timing? RESULT)<br/></dd>
    30432812<dd>
    30442813<ul>
     
    30502819
    30512820<dl>
    3052 <dt><em>(procedure)</em><code> test::expect-tolerance-result-timing</code></dt>
    3053 <dd><br />
    3054 (test::expect-tolerance-result-timing RESULT)
    3055 <br /></dd>
     2821<dt>[<em>procedure</em>] <code>test::expect-tolerance-result-timing</code></dt>
     2822<dd><br/>(test::expect-tolerance-result-timing RESULT)<br/></dd>
    30562823<dd>
    30572824<ul>
     
    30662833
    30672834<dl>
    3068 <dt><em>(procedure)</em><code> test::gloss-result?</code></dt>
    3069 <dd><br />
    3070 (test::gloss-result? RESULT)
    3071 <br /></dd>
     2835<dt>[<em>procedure</em>] <code>test::gloss-result?</code></dt>
     2836<dd><br/>(test::gloss-result? RESULT)<br/></dd>
    30722837<dd>
    30732838<ul>
     
    30802845
    30812846<dl>
    3082 <dt><em>(procedure)</em><code> test::gloss-result-message</code></dt>
    3083 <dd><br />
    3084 (test::gloss-result-message RESULT)
    3085 <br /></dd>
     2847<dt>[<em>procedure</em>] <code>test::gloss-result-message</code></dt>
     2848<dd><br/>(test::gloss-result-message RESULT)<br/></dd>
    30862849<dd>
    30872850<ul>
     
    30922855
    30932856<dl>
    3094 <dt><em>(procedure)</em><code> test::gloss-result-warning?</code></dt>
    3095 <dd><br />
    3096 (test::gloss-result-warning? RESULT)
    3097 <br /></dd>
     2857<dt>[<em>procedure</em>] <code>test::gloss-result-warning?</code></dt>
     2858<dd><br/>(test::gloss-result-warning? RESULT)<br/></dd>
    30982859<dd>
    30992860<ul>
     
    31052866
    31062867<dl>
    3107 <dt><em>(procedure)</em><code> test::gloss-result-warning</code></dt>
    3108 <dd><br />
    3109 (test::gloss-result-warning RESULT)
    3110 <br /></dd>
     2868<dt>[<em>procedure</em>] <code>test::gloss-result-warning</code></dt>
     2869<dd><br/>(test::gloss-result-warning RESULT)<br/></dd>
    31112870<dd>
    31122871<ul>
     
    31222881
    31232882<dl>
    3124 <dt><em>(procedure)</em><code> test::skip-result?</code></dt>
    3125 <dd><br />
    3126 (test::skip-result? RESULT)
    3127 <br /></dd>
     2883<dt>[<em>procedure</em>] <code>test::skip-result?</code></dt>
     2884<dd><br/>(test::skip-result? RESULT)<br/></dd>
    31282885<dd>
    31292886<ul>
     
    31362893
    31372894<dl>
    3138 <dt><em>(procedure)</em><code> test::skip-result-message</code></dt>
    3139 <dd><br />
    3140 (test::skip-result-message RESULT)
    3141 <br /></dd>
     2895<dt>[<em>procedure</em>] <code>test::skip-result-message</code></dt>
     2896<dd><br/>(test::skip-result-message RESULT)<br/></dd>
    31422897<dd>
    31432898<ul>
     
    31492904
    31502905<dl>
    3151 <dt><em>(procedure)</em><code> test::skip-result-warning?</code></dt>
    3152 <dd><br />
    3153 (test::skip-result-warning? RESULT)
    3154 <br /></dd>
     2906<dt>[<em>procedure</em>] <code>test::skip-result-warning?</code></dt>
     2907<dd><br/>(test::skip-result-warning? RESULT)<br/></dd>
    31552908<dd>
    31562909<ul>
     
    31622915
    31632916<dl>
    3164 <dt><em>(procedure)</em><code> test::skip-result-warning</code></dt>
    3165 <dd><br />
    3166 (test::skip-result-warning RESULT)
    3167 <br /></dd>
     2917<dt>[<em>procedure</em>] <code>test::skip-result-warning</code></dt>
     2918<dd><br/>(test::skip-result-warning RESULT)<br/></dd>
    31682919<dd>
    31692920<ul>
     
    31832934
    31842935<dl>
    3185 <dt><em>(procedure)</em><code> test::terminate-result?</code></dt>
    3186 <dd><br />
    3187 (test::terminate-result? RESULT)
    3188 <br /></dd>
     2936<dt>[<em>procedure</em>] <code>test::terminate-result?</code></dt>
     2937<dd><br/>(test::terminate-result? RESULT)<br/></dd>
    31892938<dd>
    31902939<ul>
     
    31972946
    31982947<dl>
    3199 <dt><em>(procedure)</em><code> test::terminate-result-finding</code></dt>
    3200 <dd><br />
    3201 (test::terminate-result-finding RESULT)
    3202 <br /></dd>
     2948<dt>[<em>procedure</em>] <code>test::terminate-result-finding</code></dt>
     2949<dd><br/>(test::terminate-result-finding RESULT)<br/></dd>
    32032950<dd>
    32042951<ul>
     
    32092956
    32102957<dl>
    3211 <dt><em>(procedure)</em><code> test::terminate-result-scope</code></dt>
    3212 <dd><br />
    3213 (test::terminate-result-scope RESULT)
    3214 <br /></dd>
     2958<dt>[<em>procedure</em>] <code>test::terminate-result-scope</code></dt>
     2959<dd><br/>(test::terminate-result-scope RESULT)<br/></dd>
    32152960<dd>
    32162961<ul>
     
    32232968
    32242969<dl>
    3225 <dt><em>(procedure)</em><code> test::terminate-result-container</code></dt>
    3226 <dd><br />
    3227 (test::terminate-result-container RESULT)
    3228 <br /></dd>
     2970<dt>[<em>procedure</em>] <code>test::terminate-result-container</code></dt>
     2971<dd><br/>(test::terminate-result-container RESULT)<br/></dd>
    32292972<dd>
    32302973<ul>
     
    32372980
    32382981<dl>
    3239 <dt><em>(procedure)</em><code> test::terminate-result-message</code></dt>
    3240 <dd><br />
    3241 (test::terminate-result-message RESULT)
    3242 <br /></dd>
     2982<dt>[<em>procedure</em>] <code>test::terminate-result-message</code></dt>
     2983<dd><br/>(test::terminate-result-message RESULT)<br/></dd>
    32432984<dd>
    32442985<ul>
     
    32532994
    32542995<dl>
    3255 <dt><em>(procedure)</em><code> test::todo-result?</code></dt>
    3256 <dd><br />
    3257 (test::todo-result? RESULT)
    3258 <br /></dd>
     2996<dt>[<em>procedure</em>] <code>test::todo-result?</code></dt>
     2997<dd><br/>(test::todo-result? RESULT)<br/></dd>
    32592998<dd>
    32602999<ul>
     
    32673006
    32683007<dl>
    3269 <dt><em>(procedure)</em><code> test::todo-result-message</code></dt>
    3270 <dd><br />
    3271 (test::todo-result-message RESULT)
    3272 <br /></dd>
     3008<dt>[<em>procedure</em>] <code>test::todo-result-message</code></dt>
     3009<dd><br/>(test::todo-result-message RESULT)<br/></dd>
    32733010<dd>
    32743011<ul>
     
    32793016
    32803017<dl>
    3281 <dt><em>(procedure)</em><code> test::todo-result-warning?</code></dt>
    3282 <dd><br />
    3283 (test::todo-result-warning? RESULT)
    3284 <br /></dd>
     3018<dt>[<em>procedure</em>] <code>test::todo-result-warning?</code></dt>
     3019<dd><br/>(test::todo-result-warning? RESULT)<br/></dd>
    32853020<dd>
    32863021<ul>
     
    32923027
    32933028<dl>
    3294 <dt><em>(procedure)</em><code> test::todo-result-warning</code></dt>
    3295 <dd><br />
    3296 (test::todo-result-warning RESULT)
    3297 <br /></dd>
     3029<dt>[<em>procedure</em>] <code>test::todo-result-warning</code></dt>
     3030<dd><br/>(test::todo-result-warning RESULT)<br/></dd>
    32983031<dd>
    32993032<ul>
     
    33093042
    33103043<dl>
    3311 <dt><em>(procedure)</em><code> test::walk-structure</code></dt>
    3312 <dd><br />
    3313 (test::walk-structure WALKER TEST-STRUCTURE)
    3314 <br /></dd>
     3044<dt>[<em>procedure</em>] <code>test::walk-structure</code></dt>
     3045<dd><br/>(test::walk-structure WALKER TEST-STRUCTURE)<br/></dd>
    33153046<dd>
    33163047<ul>
     
    33263057
    33273058<dl>
    3328 <dt><em>(procedure)</em><code> (test::stat-result-statistics RESULT-TREE)</code></dt>
     3059<dt>[<em>procedure</em>] <code>(test::stat-result-statistics RESULT-TREE)</code></dt>
    33293060<dd>
    33303061<ul>
     
    33373068
    33383069<dl>
    3339 <dt><em>(procedure)</em><code> (test::stat-test-suites STATISTICS)</code></dt>
    3340 <dt><em>(procedure)</em><code> (test::stat-test-suite-warnings STATISTICS)</code></dt>
    3341 <dt><em>(procedure)</em><code> (test::stat-test-suites-passed STATISTICS)</code></dt>
    3342 <dt><em>(procedure)</em><code> (test::stat-test-suites-failed STATISTICS)</code></dt>
    3343 <dt><em>(procedure)</em><code> (test::stat-test-suites-timing STATISTICS)</code></dt>
    3344 <dt><em>(procedure)</em><code> (test::stat-test-suites-terminated STATISTICS)</code></dt>
    3345 <dt><em>(procedure)</em><code> (test::stat-test-cases STATISTICS)</code></dt>
    3346 <dt><em>(procedure)</em><code> (test::stat-test-case-warnings STATISTICS)</code></dt>
    3347 <dt><em>(procedure)</em><code> (test::stat-test-cases-passed STATISTICS)</code></dt>
    3348 <dt><em>(procedure)</em><code> (test::stat-test-cases-failed STATISTICS)</code></dt>
    3349 <dt><em>(procedure)</em><code> (test::stat-test-cases-timing STATISTICS)</code></dt>
    3350 <dt><em>(procedure)</em><code> (test::stat-test-cases-terminated STATISTICS)</code></dt>
    3351 <dt><em>(procedure)</em><code> (test::stat-all-expectations STATISTICS)</code></dt>
    3352 <dt><em>(procedure)</em><code> (test::stat-all-expectation-warnings STATISTICS)</code></dt>
    3353 <dt><em>(procedure)</em><code> (test::stat-all-expectations-passed STATISTICS)</code></dt>
    3354 <dt><em>(procedure)</em><code> (test::stat-all-expectations-failed STATISTICS)</code></dt>
    3355 <dt><em>(procedure)</em><code> (test::stat-all-expectations-timing STATISTICS)</code></dt>
    3356 <dt><em>(procedure)</em><code> (test::stat-single-expectations STATISTICS)</code></dt>
    3357 <dt><em>(procedure)</em><code> (test::stat-single-expectation-warnings STATISTICS)</code></dt>
    3358 <dt><em>(procedure)</em><code> (test::stat-single-expectations-passed STATISTICS)</code></dt>
    3359 <dt><em>(procedure)</em><code> (test::stat-single-expectations-failed STATISTICS)</code></dt>
    3360 <dt><em>(procedure)</em><code> (test::stat-single-expectations-timing STATISTICS)</code></dt>
    3361 <dt><em>(procedure)</em><code> (test::stat-tol-expectations STATISTICS)</code></dt>
    3362 <dt><em>(procedure)</em><code> (test::stat-tol-expectation-warnings STATISTICS)</code></dt>
    3363 <dt><em>(procedure)</em><code> (test::stat-tol-expectations-passed STATISTICS)</code></dt>
    3364 <dt><em>(procedure)</em><code> (test::stat-tol-expectations-failed STATISTICS)</code></dt>
    3365 <dt><em>(procedure)</em><code> (test::stat-tol-expectations-timing STATISTICS)</code></dt>
    3366 <dt><em>(procedure)</em><code> (test::stat-equiv-expectations STATISTICS)</code></dt>
    3367 <dt><em>(procedure)</em><code> (test::stat-equiv-expectation-warnings STATISTICS)</code></dt>
    3368 <dt><em>(procedure)</em><code> (test::stat-equiv-expectations-passed STATISTICS)</code></dt>
    3369 <dt><em>(procedure)</em><code> (test::stat-equiv-expectations-failed STATISTICS)</code></dt>
    3370 <dt><em>(procedure)</em><code> (test::stat-equiv-expectations-timing STATISTICS)</code></dt>
    3371 <dt><em>(procedure)</em><code> (test::stat-todos STATISTICS)</code></dt>
    3372 <dt><em>(procedure)</em><code> (test::stat-todo-warnings STATISTICS)</code></dt>
    3373 <dt><em>(procedure)</em><code> (test::stat-skips STATISTICS)</code></dt>
    3374 <dt><em>(procedure)</em><code> (test::stat-skip-warnings STATISTICS)</code></dt>
    3375 <dt><em>(procedure)</em><code> (test::stat-glosses STATISTICS)</code></dt>
    3376 <dt><em>(procedure)</em><code> (test::stat-gloss-warnings STATISTICS)</code></dt>
    3377 <dt><em>(procedure)</em><code> (test::stat-terminations STATISTICS)</code></dt>
     3070<dt>[<em>procedure</em>] <code>(test::stat-test-suites STATISTICS)</code></dt>
     3071<dt>[<em>procedure</em>] <code>(test::stat-test-suite-warnings STATISTICS)</code></dt>
     3072<dt>[<em>procedure</em>] <code>(test::stat-test-suites-passed STATISTICS)</code></dt>
     3073<dt>[<em>procedure</em>] <code>(test::stat-test-suites-failed STATISTICS)</code></dt>
     3074<dt>[<em>procedure</em>] <code>(test::stat-test-suites-timing STATISTICS)</code></dt>
     3075<dt>[<em>procedure</em>] <code>(test::stat-test-suites-terminated STATISTICS)</code></dt>
     3076<dt>[<em>procedure</em>] <code>(test::stat-test-cases STATISTICS)</code></dt>
     3077<dt>[<em>procedure</em>] <code>(test::stat-test-case-warnings STATISTICS)</code></dt>
     3078<dt>[<em>procedure</em>] <code>(test::stat-test-cases-passed STATISTICS)</code></dt>
     3079<dt>[<em>procedure</em>] <code>(test::stat-test-cases-failed STATISTICS)</code></dt>
     3080<dt>[<em>procedure</em>] <code>(test::stat-test-cases-timing STATISTICS)</code></dt>
     3081<dt>[<em>procedure</em>] <code>(test::stat-test-cases-terminated STATISTICS)</code></dt>
     3082<dt>[<em>procedure</em>] <code>(test::stat-all-expectations STATISTICS)</code></dt>
     3083<dt>[<em>procedure</em>] <code>(test::stat-all-expectation-warnings STATISTICS)</code></dt>
     3084<dt>[<em>procedure</em>] <code>(test::stat-all-expectations-passed STATISTICS)</code></dt>
     3085<dt>[<em>procedure</em>] <code>(test::stat-all-expectations-failed STATISTICS)</code></dt>
     3086<dt>[<em>procedure</em>] <code>(test::stat-all-expectations-timing STATISTICS)</code></dt>
     3087<dt>[<em>procedure</em>] <code>(test::stat-single-expectations STATISTICS)</code></dt>
     3088<dt>[<em>procedure</em>] <code>(test::stat-single-expectation-warnings STATISTICS)</code></dt>
     3089<dt>[<em>procedure</em>] <code>(test::stat-single-expectations-passed STATISTICS)</code></dt>
     3090<dt>[<em>procedure</em>] <code>(test::stat-single-expectations-failed STATISTICS)</code></dt>
     3091<dt>[<em>procedure</em>] <code>(test::stat-single-expectations-timing STATISTICS)</code></dt>
     3092<dt>[<em>procedure</em>] <code>(test::stat-tol-expectations STATISTICS)</code></dt>
     3093<dt>[<em>procedure</em>] <code>(test::stat-tol-expectation-warnings STATISTICS)</code></dt>
     3094<dt>[<em>procedure</em>] <code>(test::stat-tol-expectations-passed STATISTICS)</code></dt>
     3095<dt>[<em>procedure</em>] <code>(test::stat-tol-expectations-failed STATISTICS)</code></dt>
     3096<dt>[<em>procedure</em>] <code>(test::stat-tol-expectations-timing STATISTICS)</code></dt>
     3097<dt>[<em>procedure</em>] <code>(test::stat-equiv-expectations STATISTICS)</code></dt>
     3098<dt>[<em>procedure</em>] <code>(test::stat-equiv-expectation-warnings STATISTICS)</code></dt>
     3099<dt>[<em>procedure</em>] <code>(test::stat-equiv-expectations-passed STATISTICS)</code></dt>
     3100<dt>[<em>procedure</em>] <code>(test::stat-equiv-expectations-failed STATISTICS)</code></dt>
     3101<dt>[<em>procedure</em>] <code>(test::stat-equiv-expectations-timing STATISTICS)</code></dt>
     3102<dt>[<em>procedure</em>] <code>(test::stat-todos STATISTICS)</code></dt>
     3103<dt>[<em>procedure</em>] <code>(test::stat-todo-warnings STATISTICS)</code></dt>
     3104<dt>[<em>procedure</em>] <code>(test::stat-skips STATISTICS)</code></dt>
     3105<dt>[<em>procedure</em>] <code>(test::stat-skip-warnings STATISTICS)</code></dt>
     3106<dt>[<em>procedure</em>] <code>(test::stat-glosses STATISTICS)</code></dt>
     3107<dt>[<em>procedure</em>] <code>(test::stat-gloss-warnings STATISTICS)</code></dt>
     3108<dt>[<em>procedure</em>] <code>(test::stat-terminations STATISTICS)</code></dt>
    33783109</dl>
    33793110
     
    33843115
    33853116<dl>
    3386 <dt><em>(procedure)</em><code> (test::write-object OBJECT)</code></dt>
    3387 <dt><em>(procedure)</em><code> (test::display-objects [OBJECT ...])</code></dt>
    3388 <dt><em>(procedure)</em><code> (test::display-objects-newline [OBJECT ...])</code></dt>
    3389 <dt><em>(procedure)</em><code> (test::display-indent INDENT)</code></dt>
    3390 <dt><em>(procedure)</em><code> (test::display-indented-objects INDENT [OBJECT ...])</code></dt>
    3391 <dt><em>(procedure)</em><code> (test::display-indented-objects-newline INDENT [OBJECT ...])</code></dt>
     3117<dt>[<em>procedure</em>] <code>(test::write-object OBJECT)</code></dt>
     3118<dt>[<em>procedure</em>] <code>(test::display-objects [OBJECT ...])</code></dt>
     3119<dt>[<em>procedure</em>] <code>(test::display-objects-newline [OBJECT ...])</code></dt>
     3120<dt>[<em>procedure</em>] <code>(test::display-indent INDENT)</code></dt>
     3121<dt>[<em>procedure</em>] <code>(test::display-indented-objects INDENT [OBJECT ...])</code></dt>
     3122<dt>[<em>procedure</em>] <code>(test::display-indented-objects-newline INDENT [OBJECT ...])</code></dt>
    33923123</dl>
    33933124<ul>
     
    33973128
    33983129<dl>
    3399 <dt><em>(procedure)</em><code> (test::display-underlined [OBJECT ...])</code></dt>
     3130<dt>[<em>procedure</em>] <code>(test::display-underlined [OBJECT ...])</code></dt>
    34003131<ul>
    34013132<li>Prints each supplied <code>OBJECT</code> to the
     
    34063137
    34073138<dl>
    3408 <dt><em>(procedure)</em><code> (test::display-structure TEST-STRUCTURE)</code></dt>
     3139<dt>[<em>procedure</em>] <code>(test::display-structure TEST-STRUCTURE)</code></dt>
    34093140<ul>
    34103141<li>Prints the supplied <code>TEST-STRUCTURE</code> tree to the
     
    34203151
    34213152<dl>
    3422 <dt><em>(procedure)</em><code> (test::output-style-compact RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
     3153<dt>[<em>procedure</em>] <code>(test::output-style-compact RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
    34233154<ul>
    34243155<li>Prints a simple listing of the test results. Details are only printed for
    34253156failed tests.</li>
    34263157</ul>
    3427 <dt><em>(procedure)</em><code> (test::output-style-human RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
     3158<dt>[<em>procedure</em>] <code>(test::output-style-human RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
    34283159<ul>
    34293160<li>Prints a verbose listing of the test results.</li>
    34303161</ul>
    3431 <dt><em>(procedure)</em><code> (test::output-style-html RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
     3162<dt>[<em>procedure</em>] <code>(test::output-style-html RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
    34323163<ul>
    34333164<li>Prints a verbose listing of the test results as HTML.</li>
    34343165</ul>
    3435 <dt><em>(procedure)</em><code> (test::output-style-minimal RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
     3166<dt>[<em>procedure</em>] <code>(test::output-style-minimal RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
    34363167<ul>
    34373168<li>Prints a summary of the test result statistics.</li>
     
    34423173be loaded explicitly, as in:</p>
    34433174<code>(require-extension testbase-output-human)</code>
    3444 <br />
     3175<br/>
    34453176<code>(require-extension testbase-output-html)</code>
    3446 <br />
     3177<br/>
    34473178<code>(require-extension testbase-output-compact)</code>
    3448 <br />
     3179<br/>
    34493180<code>(require-extension testbase-output-minimal)</code>
    34503181
     
    34533184
    34543185<dl>
    3455 <dt><em>(procedure)</em><code> (test::with-output-style STYLER RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
     3186<dt>[<em>procedure</em>] <code>(test::with-output-style STYLER RESULT-TREE [PORT|FILE-NAME|#t])</code></dt>
    34563187<ul>
    34573188<li><code>STYLER</code> is a procedure with a single argument, a
     
    36373368  Test Case: Are 0 - 9 integers?
    36383369
    3639     Expectation: 
     3370    Expectation:
    36403371    Expect true
    36413372    Unevaluated: (integer? i)
    36423373      Evaluated: #t
    3643     Passed: 
    3644 
    3645     Expectation: 
     3374    Passed:
     3375
     3376    Expectation:
    36463377    Expect true
    36473378    Unevaluated: (integer? i)
    36483379      Evaluated: #t
    3649     Passed: 
    3650 
    3651     Expectation: 
     3380    Passed:
     3381
     3382    Expectation:
    36523383    Expect true
    36533384    Unevaluated: (integer? i)
    36543385      Evaluated: #t
    3655     Passed: 
    3656 
    3657     Expectation: 
     3386    Passed:
     3387
     3388    Expectation:
    36583389    Expect true
    36593390    Unevaluated: (integer? i)
    36603391      Evaluated: #t
    3661     Passed: 
    3662 
    3663     Expectation: 
     3392    Passed:
     3393
     3394    Expectation:
    36643395    Expect true
    36653396    Unevaluated: (integer? i)
    36663397      Evaluated: #t
    3667     Passed: 
    3668 
    3669     Expectation: 
     3398    Passed:
     3399
     3400    Expectation:
    36703401    Expect true
    36713402    Unevaluated: (integer? i)
    36723403      Evaluated: #t
    3673     Passed: 
    3674 
    3675     Expectation: 
     3404    Passed:
     3405
     3406    Expectation:
    36763407    Expect true
    36773408    Unevaluated: (integer? i)
    36783409      Evaluated: #t
    3679     Passed: 
    3680 
    3681     Expectation: 
     3410    Passed:
     3411
     3412    Expectation:
    36823413    Expect true
    36833414    Unevaluated: (integer? i)
    36843415      Evaluated: #t
    3685     Passed: 
    3686 
    3687     Expectation: 
     3416    Passed:
     3417
     3418    Expectation:
    36883419    Expect true
    36893420    Unevaluated: (integer? i)
    36903421      Evaluated: #t
    3691     Passed: 
    3692 
    3693     Expectation: 
     3422    Passed:
     3423
     3424    Expectation:
    36943425    Expect true
    36953426    Unevaluated: (integer? i)
    36963427      Evaluated: #t
    3697     Passed: 
     3428    Passed:
    36983429
    36993430  Passed: Are 0 - 9 integers?
     
    37993530<p>Because a sharp-syntax reader is created to handle "unprintable" results the
    38003531"#&lt;&lt;TAG" & "#&lt;#TAG" multiline string constant read syntax cannot be used within
    3801 a test-file.</p>
     3532a test-file. Use <code>(MULTILINE-STRING STRING ...)</code>.</p>
    38023533
    38033534
     
    38083539<h3>Version</h3>
    38093540<ul>
     3541<li>1.5 Added 'insist' expectation form</li>
    38103542<li>1.41 Cygwin has resource limiting</li>
    38113543<li>1.4 Expansion options are #f by default, expcept test::catching!</li>
Note: See TracChangeset for help on using the changeset viewer.