From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: "=?ISO-8859-1?Q?Germ=E1n?= A. Arias" Newsgroups: gmane.lisp.guile.user Subject: Re: Problem with guile on Dragora Date: Sat, 5 May 2012 19:12:23 -0600 Message-ID: <20120505191223.7c0436de@rafaela> References: <20120502003631.58d9d08a@rafaela> <20120502015105.0a8b8d6f@rafaela> NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="MP_/zCFpupYXKUZ9reVjPK9fne+" X-Trace: dough.gmane.org 1336245190 12814 80.91.229.3 (5 May 2012 19:13:10 GMT) X-Complaints-To: usenet@dough.gmane.org NNTP-Posting-Date: Sat, 5 May 2012 19:13:10 +0000 (UTC) Cc: Ludovic =?ISO-8859-1?Q?Court=E8s?= , guile-user@gnu.org To: Sunjoong Lee Original-X-From: guile-user-bounces+guile-user=m.gmane.org@gnu.org Sat May 05 21:13:07 2012 Return-path: Envelope-to: guile-user@m.gmane.org Original-Received: from lists.gnu.org ([208.118.235.17]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1SQkPi-0001t8-Ml for guile-user@m.gmane.org; Sat, 05 May 2012 21:13:07 +0200 Original-Received: from localhost ([::1]:40985 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SQkPi-0003Wk-0o for guile-user@m.gmane.org; Sat, 05 May 2012 15:13:06 -0400 Original-Received: from eggs.gnu.org ([208.118.235.92]:48052) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SQkPT-0003WU-H9 for guile-user@gnu.org; Sat, 05 May 2012 15:12:59 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1SQkPJ-0006zU-6F for guile-user@gnu.org; Sat, 05 May 2012 15:12:51 -0400 Original-Received: from mail-gh0-f169.google.com ([209.85.160.169]:63449 helo=mail-gy0-f169.google.com) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SQkPI-0006z9-T6 for guile-user@gnu.org; Sat, 05 May 2012 15:12:41 -0400 Original-Received: by ghrr18 with SMTP id r18so4344244ghr.0 for ; Sat, 05 May 2012 12:12:40 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=date:from:to:cc:subject:message-id:in-reply-to:references:x-mailer :mime-version:content-type:x-gm-message-state; bh=cjXCjIoZ/1ChZTLm+Fw7Cv/GJ2xcibJwCGXAaR6a4hE=; b=FL7Nh6AN6VJ3UrAP0v1YPtmAKEc8pXBFQlhQIdoTREdkpSI3c9GOYuxQLcu15LWgtM q4J8Y7yxIIBS2jxQL+eaoP+XyWt4qa2fpDhlIXc4rgk9HZYmh/8PTBfiuw9QfZw6C+KU 5QROBD5C0LEwD6+38Y9gAVNdt58zL+Wwn3g92DMe8nC7SsIJIXA+bIbjRwHJvnTGlWBT K+8hl7jEZcudEub3Lm/GlDtd9n0x9EPz+LVkVHzanYrgYrzYSNX4IjtNhG2O/7BSQ9sq 5BenAGW8+ExTCr6YlCh5aGMCAeU7TD2HO7JnuhwoVbhZBFU4xz34DLZnlXohlxGy7gqj /TkQ== Original-Received: by 10.236.75.232 with SMTP id z68mr13862631yhd.6.1336245159952; Sat, 05 May 2012 12:12:39 -0700 (PDT) Original-Received: from rafaela ([186.151.109.211]) by mx.google.com with ESMTPS id i7sm19522080ani.17.2012.05.05.12.12.36 (version=SSLv3 cipher=OTHER); Sat, 05 May 2012 12:12:39 -0700 (PDT) In-Reply-To: X-Mailer: Claws Mail 3.8.0cvs39 (GTK+ 2.24.10; i486-dragora-linux-gnu) X-Gm-Message-State: ALoCoQltZQs1XnrgMo/un1xyt0QGc5S0nw92ndFmEBKH8xKPBfY/8r/o/AB7aUP5LM4qxDDaS1B3 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 209.85.160.169 X-BeenThere: guile-user@gnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: General Guile related discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guile-user-bounces+guile-user=m.gmane.org@gnu.org Original-Sender: guile-user-bounces+guile-user=m.gmane.org@gnu.org Xref: news.gmane.org gmane.lisp.guile.user:9452 Archived-At: --MP_/zCFpupYXKUZ9reVjPK9fne+ Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-Disposition: inline El Sat, 5 May 2012 04:46:45 +0900 Sunjoong Lee escribi=F3: > Hi, Germ=E1n; >=20 > 2012/5/4 Ludovic Court=E8s >=20 > > Could you apply this patch and confirm? Alternatively, you can try > > a tarball from > > . > > >=20 > When checking the new patched version of Guile, there is "check-guile" > script in root of Guile source directory. After "./configure" and > "make", you can execute this script "./check-guile" and it will > display many information like this: > ..... > ..... > Running vlist.test > Running weaks.test > Running web-http.test > Running web-request.test > Running web-response.test > Running web-uri.test >=20 > Totals for this test run: > passes: 34414 > failures: 2 > unexpected passes: 0 > expected failures: 30 > unresolved test cases: 578 > untested test cases: 1 > unsupported test cases: 9 > errors: 0 >=20 > This script write a log file, check-guile.log. In above case, there > is 2 failures. you can grep like this: > $ grep ^FAIL check-guile.log > FAIL: gc.test: gc: Lexical vars are collectable > FAIL: threads.test: mutex-ownership: mutex with owner not retained > (bug #27450) >=20 > If you find errors, use ^ERROR instead of ^FAIL. There no "FAIL" or "ERROR", just "WARNINGS". Attached the check-guile.log. --MP_/zCFpupYXKUZ9reVjPK9fne+ Content-Type: text/x-log Content-Transfer-Encoding: quoted-printable Content-Disposition: attachment; filename=check-guile.log PASS: 00-initial-env.test: goopsless: + wrong type argument: 1st argument s= tring (eval) PASS: 00-initial-env.test: goopsless: + wrong type argument: 1st argument s= tring (compile) PASS: 00-initial-env.test: goopsless: + wrong type argument: 2nd argument b= ool (eval) PASS: 00-initial-env.test: goopsless: + wrong type argument: 2nd argument b= ool (compile) PASS: 00-initial-env.test: goopsless: + wrong type argument: implicit forci= ng is not supported (eval) PASS: 00-initial-env.test: goopsless: + wrong type argument: implicit forci= ng is not supported (compile) PASS: 00-initial-env.test: goopsless: - wrong type argument: 1st argument s= tring (eval) PASS: 00-initial-env.test: goopsless: - wrong type argument: 1st argument s= tring (compile) PASS: 00-initial-env.test: goopsless: - wrong type argument: 2nd argument s= ymbol (eval) PASS: 00-initial-env.test: goopsless: - wrong type argument: 2nd argument s= ymbol (compile) PASS: alist.test: acons PASS: alist.test: sloppy-assq PASS: alist.test: sloppy-assq not PASS: alist.test: sloppy-assv PASS: alist.test: sloppy-assv not PASS: alist.test: sloppy-assoc PASS: alist.test: sloppy-assoc not PASS: alist.test: assq PASS: alist.test: assq deformed PASS: alist.test: assq not PASS: alist.test: assv PASS: alist.test: assv deformed PASS: alist.test: assv not PASS: alist.test: assoc PASS: alist.test: assoc deformed PASS: alist.test: assoc not PASS: alist.test: assq-ref PASS: alist.test: assq-ref not PASS: alist.test: assv-ref PASS: alist.test: assv-ref not PASS: alist.test: assoc-ref PASS: alist.test: assoc-ref not UNSUPPORTED: alist.test: assv-ref deformed UNSUPPORTED: alist.test: assoc-ref deformed UNSUPPORTED: alist.test: assq-ref deformed PASS: alist.test: assq-set! PASS: alist.test: assq-set! add PASS: alist.test: assv-set! PASS: alist.test: assv-set! add PASS: alist.test: assoc-set! PASS: alist.test: assoc-set! add UNSUPPORTED: alist.test: assq-set! deformed UNSUPPORTED: alist.test: assv-set! deformed UNSUPPORTED: alist.test: assoc-set! deformed PASS: alist.test: assq-remove! PASS: alist.test: assv-remove! PASS: alist.test: assoc-remove! UNSUPPORTED: alist.test: assq-remove! deformed UNSUPPORTED: alist.test: assv-remove! deformed UNSUPPORTED: alist.test: assoc-remove! deformed PASS: and-let-star.test: and-let*: cond-expand srfi-2 PASS: and-let-star.test: and-let*: no bindings: no result expression (gives= #t) PASS: and-let-star.test: and-let*: no bindings: result expression PASS: and-let-star.test: and-let*: no bindings: two result expressions PASS: and-let-star.test: and-let*: one binding: no result expression (gives= #t) PASS: and-let-star.test: and-let*: one binding: result expression PASS: and-let-star.test: and-let*: one binding: result variable PASS: and-let-star.test: and-let*: one binding: two result expressions PASS: and-let-star.test: and-let*: one test: no result expression (gives #t) PASS: and-let-star.test: and-let*: one test: result expression PASS: and-let-star.test: and-let*: one test: two result expressions PASS: arbiters.test: arbiter display: never locked PASS: arbiters.test: arbiter display: locked PASS: arbiters.test: arbiter display: unlocked PASS: arbiters.test: try-arbiter: lock PASS: arbiters.test: try-arbiter: already locked PASS: arbiters.test: try-arbiter: already locked twice PASS: arbiters.test: release-arbiter: lock PASS: arbiters.test: release-arbiter: never locked PASS: arbiters.test: release-arbiter: never locked twice PASS: arbiters.test: release-arbiter: already unlocked PASS: arbiters.test: release-arbiter: already unlocked twice PASS: arrays.test: sanity: (not (uniform-vector? 12345678901234567890123456= 789)) PASS: arrays.test: array?: is bool: (eq? #t (typed-array? bool (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? char (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? byte (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? short (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? ulong (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? long (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? longlong (quote b= ))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? float (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? double (quote b))) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? complex (quote b)= )) PASS: arrays.test: array?: is bool: (eq? #f (typed-array? scm (quote b))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? bool (quote a))) PASS: arrays.test: array?: is char: (eq? #t (typed-array? char (quote a))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? byte (quote a))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? short (quote a))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? ulong (quote a))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? long (quote a))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? longlong (quote a= ))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? float (quote a))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? double (quote a))) PASS: arrays.test: array?: is char: (eq? #f (typed-array? complex (quote a)= )) PASS: arrays.test: array?: is char: (eq? #f (typed-array? scm (quote a))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? bool (quote u8))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? char (quote u8))) PASS: arrays.test: array?: is byte: (eq? #t (typed-array? byte (quote u8))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? short (quote u8))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? ulong (quote u8))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? long (quote u8))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? longlong (quote u= 8))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? float (quote u8))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? double (quote u8)= )) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? complex (quote u8= ))) PASS: arrays.test: array?: is byte: (eq? #f (typed-array? scm (quote u8))) PASS: arrays.test: array?: is short: (eq? #f (typed-array? bool (quote s16)= )) PASS: arrays.test: array?: is short: (eq? #f (typed-array? char (quote s16)= )) PASS: arrays.test: array?: is short: (eq? #f (typed-array? byte (quote s16)= )) PASS: arrays.test: array?: is short: (eq? #t (typed-array? short (quote s16= ))) PASS: arrays.test: array?: is short: (eq? #f (typed-array? ulong (quote s16= ))) PASS: arrays.test: array?: is short: (eq? #f (typed-array? long (quote s16)= )) PASS: arrays.test: array?: is short: (eq? #f (typed-array? longlong (quote = s16))) PASS: arrays.test: array?: is short: (eq? #f (typed-array? float (quote s16= ))) PASS: arrays.test: array?: is short: (eq? #f (typed-array? double (quote s1= 6))) PASS: arrays.test: array?: is short: (eq? #f (typed-array? complex (quote s= 16))) PASS: arrays.test: array?: is short: (eq? #f (typed-array? scm (quote s16))) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? bool (quote u32)= )) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? char (quote u32)= )) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? byte (quote u32)= )) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? short (quote u32= ))) PASS: arrays.test: array?: is ulong: (eq? #t (typed-array? ulong (quote u32= ))) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? long (quote u32)= )) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? longlong (quote = u32))) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? float (quote u32= ))) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? double (quote u3= 2))) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? complex (quote u= 32))) PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? scm (quote u32))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? bool (quote s32))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? char (quote s32))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? byte (quote s32))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? short (quote s32)= )) PASS: arrays.test: array?: is long: (eq? #f (typed-array? ulong (quote s32)= )) PASS: arrays.test: array?: is long: (eq? #t (typed-array? long (quote s32))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? longlong (quote s= 32))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? float (quote s32)= )) PASS: arrays.test: array?: is long: (eq? #f (typed-array? double (quote s32= ))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? complex (quote s3= 2))) PASS: arrays.test: array?: is long: (eq? #f (typed-array? scm (quote s32))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? bool (quote = s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? char (quote = s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? byte (quote = s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? short (quote= s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? ulong (quote= s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? long (quote = s64))) PASS: arrays.test: array?: is long long: (eq? #t (typed-array? longlong (qu= ote s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? float (quote= s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? double (quot= e s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? complex (quo= te s64))) PASS: arrays.test: array?: is long long: (eq? #f (typed-array? scm (quote s= 64))) PASS: arrays.test: array?: is float: (eq? #f (typed-array? bool (quote f32)= )) PASS: arrays.test: array?: is float: (eq? #f (typed-array? char (quote f32)= )) PASS: arrays.test: array?: is float: (eq? #f (typed-array? byte (quote f32)= )) PASS: arrays.test: array?: is float: (eq? #f (typed-array? short (quote f32= ))) PASS: arrays.test: array?: is float: (eq? #f (typed-array? ulong (quote f32= ))) PASS: arrays.test: array?: is float: (eq? #f (typed-array? long (quote f32)= )) PASS: arrays.test: array?: is float: (eq? #f (typed-array? longlong (quote = f32))) PASS: arrays.test: array?: is float: (eq? #t (typed-array? float (quote f32= ))) PASS: arrays.test: array?: is float: (eq? #f (typed-array? double (quote f3= 2))) PASS: arrays.test: array?: is float: (eq? #f (typed-array? complex (quote f= 32))) PASS: arrays.test: array?: is float: (eq? #f (typed-array? scm (quote f32))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? bool (quote f64= ))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? char (quote f64= ))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? byte (quote f64= ))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? short (quote f6= 4))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? ulong (quote f6= 4))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? long (quote f64= ))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? longlong (quote= f64))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? float (quote f6= 4))) PASS: arrays.test: array?: is double: (eq? #t (typed-array? double (quote f= 64))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? complex (quote = f64))) PASS: arrays.test: array?: is double: (eq? #f (typed-array? scm (quote f64)= )) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? bool (quote c6= 4))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? char (quote c6= 4))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? byte (quote c6= 4))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? short (quote c= 64))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? ulong (quote c= 64))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? long (quote c6= 4))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? longlong (quot= e c64))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? float (quote c= 64))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? double (quote = c64))) PASS: arrays.test: array?: is complex: (eq? #t (typed-array? complex (quote= c64))) PASS: arrays.test: array?: is complex: (eq? #f (typed-array? scm (quote c64= ))) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? bool #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? char #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? byte #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? short #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? ulong #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? long #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? longlong #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? float #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? double #t)) PASS: arrays.test: array?: is scm: (eq? #f (typed-array? complex #t)) PASS: arrays.test: array?: is scm: (eq? #t (typed-array? scm #t)) PASS: arrays.test: array-equal?: #s16(...) PASS: arrays.test: array->list: (equal? (array->list #s16(1 2 3)) (quote (1= 2 3))) PASS: arrays.test: array->list: (equal? (array->list #(1 2 3)) (quote (1 2 = 3))) PASS: arrays.test: array->list: (equal? (array->list #2((1 2) (3 4) (5 6)))= (quote ((1 2) (3 4) (5 6)))) PASS: arrays.test: array->list: (equal? (array->list #()) (quote ())) PASS: arrays.test: array-fill!: bool: #f PASS: arrays.test: array-fill!: bool: #t PASS: arrays.test: array-fill!: char: x PASS: arrays.test: array-fill!: byte: 0 PASS: arrays.test: array-fill!: byte: 127 PASS: arrays.test: array-fill!: byte: -128 PASS: arrays.test: array-fill!: byte: 128 PASS: arrays.test: array-fill!: byte: -129 PASS: arrays.test: array-fill!: byte: symbol PASS: arrays.test: array-fill!: short: 0 PASS: arrays.test: array-fill!: short: 123 PASS: arrays.test: array-fill!: short: -123 PASS: arrays.test: array-fill!: ulong: 0 PASS: arrays.test: array-fill!: ulong: 123 PASS: arrays.test: array-fill!: ulong: -123 PASS: arrays.test: array-fill!: long: 0 PASS: arrays.test: array-fill!: long: 123 PASS: arrays.test: array-fill!: long: -123 PASS: arrays.test: array-fill!: float: 0.0 PASS: arrays.test: array-fill!: float: 123.0 PASS: arrays.test: array-fill!: float: -123.0 PASS: arrays.test: array-fill!: float: 0 PASS: arrays.test: array-fill!: float: 123 PASS: arrays.test: array-fill!: float: -123 PASS: arrays.test: array-fill!: float: 5/8 PASS: arrays.test: array-fill!: double: 0.0 PASS: arrays.test: array-fill!: double: 123.0 PASS: arrays.test: array-fill!: double: -123.0 PASS: arrays.test: array-fill!: double: 0 PASS: arrays.test: array-fill!: double: 123 PASS: arrays.test: array-fill!: double: -123 PASS: arrays.test: array-fill!: double: 5/8 PASS: arrays.test: array-in-bounds?: (let ((a (make-array #f (quote (425 42= 5))))) (eq? #f (array-in-bounds? a 0))) PASS: arrays.test: array-type: on make-foo-vector: bool PASS: arrays.test: array-type: on make-foo-vector: char PASS: arrays.test: array-type: on make-foo-vector: byte PASS: arrays.test: array-type: on make-foo-vector: short PASS: arrays.test: array-type: on make-foo-vector: ulong PASS: arrays.test: array-type: on make-foo-vector: long PASS: arrays.test: array-type: on make-foo-vector: long long PASS: arrays.test: array-type: on make-foo-vector: float PASS: arrays.test: array-type: on make-foo-vector: double PASS: arrays.test: array-type: on make-foo-vector: complex PASS: arrays.test: array-type: on make-foo-vector: scm PASS: arrays.test: array-type: on make-typed-array: b PASS: arrays.test: array-type: on make-typed-array: a PASS: arrays.test: array-type: on make-typed-array: u8 PASS: arrays.test: array-type: on make-typed-array: s8 PASS: arrays.test: array-type: on make-typed-array: u16 PASS: arrays.test: array-type: on make-typed-array: s16 PASS: arrays.test: array-type: on make-typed-array: u32 PASS: arrays.test: array-type: on make-typed-array: s32 PASS: arrays.test: array-type: on make-typed-array: u64 PASS: arrays.test: array-type: on make-typed-array: u64 PASS: arrays.test: array-type: on make-typed-array: f32 PASS: arrays.test: array-type: on make-typed-array: f64 PASS: arrays.test: array-type: on make-typed-array: c32 PASS: arrays.test: array-type: on make-typed-array: c64 PASS: arrays.test: array-set!: bitvector: one elem set #t PASS: arrays.test: array-set!: bitvector: one elem set #f PASS: arrays.test: array-set!: byte: -128 PASS: arrays.test: array-set!: byte: 0 PASS: arrays.test: array-set!: byte: 127 PASS: arrays.test: array-set!: byte: -129 PASS: arrays.test: array-set!: byte: 128 PASS: arrays.test: array-set!: short: store/fetch: 1 PASS: arrays.test: array-set!: short: store/fetch: 3 PASS: arrays.test: array-set!: short: store/fetch: 7 PASS: arrays.test: array-set!: short: store/fetch: 15 PASS: arrays.test: array-set!: short: store/fetch: 31 PASS: arrays.test: array-set!: short: store/fetch: 63 PASS: arrays.test: array-set!: short: store/fetch: 127 PASS: arrays.test: array-set!: short: store/fetch: 255 PASS: arrays.test: array-set!: short: store/fetch: 511 PASS: arrays.test: array-set!: short: store/fetch: 1023 PASS: arrays.test: array-set!: short: store/fetch: 2047 PASS: arrays.test: array-set!: short: store/fetch: 4095 PASS: arrays.test: array-set!: short: store/fetch: 8191 PASS: arrays.test: array-set!: short: store/fetch: 16383 PASS: arrays.test: array-set!: short: store/fetch: 32767 PASS: arrays.test: array-set!: short: store/fetch: -1 PASS: arrays.test: array-set!: short: store/fetch: -2 PASS: arrays.test: array-set!: short: store/fetch: -4 PASS: arrays.test: array-set!: short: store/fetch: -8 PASS: arrays.test: array-set!: short: store/fetch: -16 PASS: arrays.test: array-set!: short: store/fetch: -32 PASS: arrays.test: array-set!: short: store/fetch: -64 PASS: arrays.test: array-set!: short: store/fetch: -128 PASS: arrays.test: array-set!: short: store/fetch: -256 PASS: arrays.test: array-set!: short: store/fetch: -512 PASS: arrays.test: array-set!: short: store/fetch: -1024 PASS: arrays.test: array-set!: short: store/fetch: -2048 PASS: arrays.test: array-set!: short: store/fetch: -4096 PASS: arrays.test: array-set!: short: store/fetch: -8192 PASS: arrays.test: array-set!: short: store/fetch: -16384 PASS: arrays.test: array-set!: short: store/fetch: -32768 PASS: arrays.test: array-set!: one dim: start PASS: arrays.test: array-set!: one dim: end PASS: arrays.test: array-set!: one dim: start-1 PASS: arrays.test: array-set!: one dim: end+1 PASS: arrays.test: array-set!: one dim: two indexes PASS: arrays.test: array-set!: two dim: start PASS: arrays.test: array-set!: two dim: end PASS: arrays.test: array-set!: two dim: start i-1 PASS: arrays.test: array-set!: two dim: end i+1 PASS: arrays.test: array-set!: two dim: one index PASS: arrays.test: array-set!: two dim: three indexes PASS: arrays.test: make-shared-array: vector unchanged PASS: arrays.test: make-shared-array: vector, high too big PASS: arrays.test: make-shared-array: vector, low too big PASS: arrays.test: make-shared-array: truncate columns PASS: arrays.test: make-shared-array: pick one column PASS: arrays.test: make-shared-array: diagonal PASS: arrays.test: make-shared-array: 2 dims from 1 dim PASS: arrays.test: make-shared-array: reverse columns PASS: arrays.test: make-shared-array: fixed offset, 0 based becomes 1 based PASS: arrays.test: make-shared-array: stride every third element PASS: arrays.test: make-shared-array: shared of shared PASS: arrays.test: uniform-vector-ref: byte: 0 PASS: arrays.test: uniform-vector-ref: byte: 127 PASS: arrays.test: uniform-vector-ref: byte: -128 PASS: arrays.test: syntax: rank and lower bounds PASS: arrays.test: syntax: negative lower bound PASS: arrays.test: syntax: negative length PASS: arrays.test: syntax: bitvector is self-evaluating PASS: arrays.test: equal?: array and non-array PASS: arrays.test: equal?: empty vectors of different types PASS: arrays.test: equal?: empty arrays of different types PASS: arrays.test: equal?: empty arrays of the same type PASS: arrays.test: equal?: identical uniform vectors of the same type PASS: arrays.test: equal?: nonidentical uniform vectors of the same type PASS: arrays.test: equal?: identical uniform vectors of different types PASS: arrays.test: equal?: nonidentical uniform vectors of different types PASS: arrays.test: equal?: vector and one-dimensional array PASS: arrays.test: generalized vector slices: (equal? (array-row array 1) #= u32(2 3)) PASS: arrays.test: generalized vector slices: (equal? (array-ref (array-row= array 1) 0) 2) PASS: arrays.test: generalized vector slices: (equal? (generalized-vector-r= ef (array-row array 1) 0) 2) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (make-int8 3= )) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (mak= e-int8 3) #vu8(9 3)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-number= 3.14)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (loa= d-number 3.14) #vu8(101 0 0 4 51 46 49 52)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-string= foo)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (loa= d-string foo) #vu8(102 0 0 3 102 111 111)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-symbol= foo)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (loa= d-symbol foo) #vu8(103 0 0 3 102 111 111)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-string= =C3=A6)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (loa= d-string =C3=A6) #vu8(102 0 0 1 230)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-wide-s= tring =CE=BB)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (loa= d-wide-string =CE=BB) #vu8(107 0 0 4 187 3 0 0)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-progra= m () 3 #f (make-int8 3) (return))) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (loa= d-program () 3 #f (make-int8 3) (return)) #vu8(104 3 0 0 0 0 0 0 0 9 3 67)) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-progra= m () 8 (load-program () 3 #f (make-int8 3) (return)) (make-int8 3) (return)= (nop) (nop) (nop) (nop) (nop))) PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (loa= d-program () 8 (load-program () 3 #f (make-int8 3) (return)) (make-int8 3) = (return) (nop) (nop) (nop) (nop) (nop)) #vu8(104 8 0 0 0 11 0 0 0 9 3 67 0 = 0 0 0 0 3 0 0 0 0 0 0 0 9 3 67)) PASS: asm-to-bytecode.test: cross-compilation: triplet i586-pc-gnu0.3 PASS: asm-to-bytecode.test: cross-compilation: triplet x86_64-unknown-linux= -gnu PASS: asm-to-bytecode.test: cross-compilation: triplet x86_64-unknown-kfree= bsd-gnu PASS: asm-to-bytecode.test: cross-compilation: target `i586-pc-gnu0.3' hono= red PASS: asm-to-bytecode.test: cross-compilation: target `x86_64-pc-linux-gnu'= honored PASS: asm-to-bytecode.test: cross-compilation: target `powerpc-unknown-linu= x-gnu' honored PASS: asm-to-bytecode.test: cross-compilation: target `sparc64-unknown-free= bsd8.2' honored PASS: asm-to-bytecode.test: cross-compilation: unknown target PASS: bit-operations.test: bit-extract: documented? PASS: bit-operations.test: bit-extract: extract from zero: single bit 0 PASS: bit-operations.test: bit-extract: extract from zero: single bit 1 PASS: bit-operations.test: bit-extract: extract from zero: single bit 28 PASS: bit-operations.test: bit-extract: extract from zero: single bit 29 PASS: bit-operations.test: bit-extract: extract from zero: single bit 30 PASS: bit-operations.test: bit-extract: extract from zero: single bit 31 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 b= its starting at 0 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 b= its starting at 1 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 b= its starting at 2 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 b= its starting at 28 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 b= its starting at 29 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 b= its starting at 30 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 b= its starting at 31 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit bits = starting at 0 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit bits = starting at 1 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit bits = starting at 2 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit bits = starting at 28 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit bits = starting at 29 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit bits = starting at 30 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit bits = starting at 31 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 b= its starting at 0 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 b= its starting at 1 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 b= its starting at 2 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 b= its starting at 28 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 b= its starting at 29 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 b= its starting at 30 PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 b= its starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max: single bit= 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max: single bit= 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max: single bit= 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max: single bit= 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max: single bit= 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max: single bit= 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= - 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= - 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= - 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= - 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= - 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= - 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= - 1 bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= + 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= + 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= + 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= + 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= + 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= + 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max: fixnum-bit= + 1 bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: single= bit 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: single= bit 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: single= bit 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: single= bit 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: single= bit 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: single= bit 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit - 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit - 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit - 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit - 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit - 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit - 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit - 1 bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit + 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit + 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit + 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit + 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit + 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit + 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-max + 1: fixnum= -bit + 1 bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min: single bit= 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min: single bit= 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min: single bit= 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min: single bit= 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min: single bit= 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min: single bit= 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= - 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= - 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= - 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= - 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= - 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= - 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= - 1 bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= + 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= + 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= + 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= + 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= + 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= + 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min: fixnum-bit= + 1 bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: single= bit 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: single= bit 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: single= bit 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: single= bit 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: single= bit 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: single= bit 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit - 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit - 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit - 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit - 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit - 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit - 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit - 1 bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit bits starting at 31 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit + 1 bits starting at 0 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit + 1 bits starting at 1 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit + 1 bits starting at 2 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit + 1 bits starting at 28 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit + 1 bits starting at 29 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit + 1 bits starting at 30 PASS: bit-operations.test: bit-extract: extract from fixnum-min - 1: fixnum= -bit + 1 bits starting at 31 PASS: bit-operations.test: bitshifts on word boundaries: (=3D (ash 1 32) 42= 94967296) PASS: bit-operations.test: bitshifts on word boundaries: (=3D (ash 1 64) 18= 446744073709551616) PASS: bitvectors.test: predicates: (bitvector? #*1010101010) PASS: bitvectors.test: predicates: (generalized-vector? #*1010101010) PASS: bitvectors.test: predicates: (uniform-vector? #*1010101010) PASS: bitvectors.test: predicates: (array? #*1010101010) PASS: bitvectors.test: equality: (equal? #*1010101 #*1010101) PASS: bitvectors.test: equality: (array-equal? #*1010101 #*1010101) PASS: bitvectors.test: equality: (not (equal? #*10101010 #*1010101)) PASS: bitvectors.test: equality: (not (array-equal? #*10101010 #*1010101)) PASS: bitvectors.test: lists: (equal? (bitvector->list #*10010) (quote (#t = #f #f #t #f))) PASS: bitvectors.test: lists: (equal? (array->list #*10010) (quote (#t #f #= f #t #f))) PASS: bitvectors.test: lists: (equal? (uniform-vector->list #*10010) (quote= (#t #f #f #t #f))) PASS: bitvectors.test: lists: (equal? #*10010 (list->bitvector (quote (#t #= f #f #t #f)))) PASS: bitvectors.test: ref and set: bv: (eqv? (bitvector-ref bv 0) #f) PASS: bitvectors.test: ref and set: bv: (eqv? (bitvector-ref bv 2) #t) PASS: bitvectors.test: ref and set: bv: (eqv? (bitvector-ref bv 0) #t) PASS: bitvectors.test: ref and set: uv: (eqv? (uniform-vector-ref bv 0) #f) PASS: bitvectors.test: ref and set: uv: (eqv? (uniform-vector-ref bv 2) #t) PASS: bitvectors.test: ref and set: uv: (eqv? (uniform-vector-ref bv 0) #t) PASS: bitvectors.test: bit-set*!: #t PASS: bitvectors.test: bit-set*!: #f PASS: bitvectors.test: bit-set*!: #t, shorter PASS: bitvectors.test: bit-set*!: #f, shorter PASS: brainfuck.test: (equal? (with-output-to-string (lambda () (call-with-= input-string prog (lambda (port) (read-and-compile port #:from (quote brain= fuck) #:to (quote value)))))) Hello World!) PASS: bytevectors.test: 2.2 General Operations: native-endianness (eval) PASS: bytevectors.test: 2.2 General Operations: native-endianness (compile) PASS: bytevectors.test: 2.2 General Operations: make-bytevector (eval) PASS: bytevectors.test: 2.2 General Operations: make-bytevector (compile) PASS: bytevectors.test: 2.2 General Operations: bytevector-length (eval) PASS: bytevectors.test: 2.2 General Operations: bytevector-length (compile) PASS: bytevectors.test: 2.2 General Operations: bytevector=3D? (eval) PASS: bytevectors.test: 2.2 General Operations: bytevector=3D? (compile) PASS: bytevectors.test: 2.2 General Operations: bytevector-copy! overlappin= g (eval) PASS: bytevectors.test: 2.2 General Operations: bytevector-copy! overlappin= g (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-{u8,= s8}-ref (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-{u8,= s8}-ref (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-{u8,= s8}-set! (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-{u8,= s8}-set! (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector->u8-= list (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector->u8-= list (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: u8-list->byteve= ctor (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: u8-list->byteve= ctor (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-uint= -{ref,set!} [small] (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-uint= -{ref,set!} [small] (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-uint= -set! [large] (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-uint= -set! [large] (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-uint= -{ref,set!} [large] (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-uint= -{ref,set!} [large] (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-sint= -ref [small] (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-sint= -ref [small] (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-sint= -ref [large] (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-sint= -ref [large] (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-sint= -set! [small] (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: bytevector-sint= -set! [small] (compile) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: equal? (eval) PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: equal? (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->sint-list (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->sint-list (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->uint-list (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->uint-list (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->uint-list [empty] (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->uint-list [empty] (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->sint-list [out-of-range] (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->sint-list [out-of-range] (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->sint-list [off-by-one] (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytev= ector->sint-list [off-by-one] (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: {sint= ,uint}-list->bytevector (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: {sint= ,uint}-list->bytevector (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: sint-= list->bytevector [limits] (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: sint-= list->bytevector [limits] (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: sint-= list->bytevector [out-of-range] (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: sint-= list->bytevector [out-of-range] (compile) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: uint-= list->bytevector [out-of-range] (eval) PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: uint-= list->bytevector [out-of-range] (compile) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-u16-r= ef (eval) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-u16-r= ef (compile) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-r= ef (eval) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-r= ef (compile) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-r= ef [unaligned] (eval) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-r= ef [unaligned] (compile) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-{u16,= s16}-ref (eval) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-{u16,= s16}-ref (compile) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-nativ= e-{u16,s16}-{ref,set!} (eval) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-nativ= e-{u16,s16}-{ref,set!} (compile) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-{= ref,set!} [unaligned] (eval) PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-{= ref,set!} [unaligned] (compile) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-u32-r= ef (eval) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-u32-r= ef (compile) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-s32-r= ef (eval) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-s32-r= ef (compile) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-{u32,= s32}-ref (eval) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-{u32,= s32}-ref (compile) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-{u32,= s32}-native-{ref,set!} (eval) PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-{u32,= s32}-native-{ref,set!} (compile) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-u64-r= ef (eval) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-u64-r= ef (compile) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-s64-r= ef (eval) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-s64-r= ef (compile) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-{u64,= s64}-ref (eval) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-{u64,= s64}-ref (compile) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-{u64,= s64}-native-{ref,set!} (eval) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-{u64,= s64}-native-{ref,set!} (compile) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: ref/set! with ze= ro (eval) PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: ref/set! with ze= ro (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: single,= little endian (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: single,= little endian (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: single,= big endian (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: single,= big endian (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-single-native-{ref,set!} (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-single-native-{ref,set!} (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-single-{ref,set!} (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-single-{ref,set!} (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-single-{ref,set!} [unaligned] (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-single-{ref,set!} [unaligned] (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: double,= little endian (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: double,= little endian (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: double,= big endian (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: double,= big endian (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-double-native-{ref,set!} (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-double-native-{ref,set!} (compile) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-double-{ref,set!} (eval) PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevec= tor-ieee-double-{ref,set!} (compile) PASS: bytevectors.test: 2.9 Operations on Strings: string->utf8 PASS: bytevectors.test: 2.9 Operations on Strings: string->utf8 [latin-1] PASS: bytevectors.test: 2.9 Operations on Strings: string->utf16 PASS: bytevectors.test: 2.9 Operations on Strings: string->utf16 [little] PASS: bytevectors.test: 2.9 Operations on Strings: string->utf32 PASS: bytevectors.test: 2.9 Operations on Strings: string->utf32 [Greek] PASS: bytevectors.test: 2.9 Operations on Strings: string->utf32 [little] PASS: bytevectors.test: 2.9 Operations on Strings: utf8->string PASS: bytevectors.test: 2.9 Operations on Strings: utf8->string [latin-1] PASS: bytevectors.test: 2.9 Operations on Strings: utf16->string PASS: bytevectors.test: 2.9 Operations on Strings: utf16->string [little] PASS: bytevectors.test: 2.9 Operations on Strings: utf32->string PASS: bytevectors.test: 2.9 Operations on Strings: utf32->string [little] PASS: bytevectors.test: Datum Syntax: empty PASS: bytevectors.test: Datum Syntax: simple PASS: bytevectors.test: Datum Syntax: >127 PASS: bytevectors.test: Datum Syntax: self-evaluating? PASS: bytevectors.test: Datum Syntax: self-evaluating PASS: bytevectors.test: Datum Syntax: quoted PASS: bytevectors.test: Datum Syntax: literal simple PASS: bytevectors.test: Datum Syntax: literal >127 PASS: bytevectors.test: Datum Syntax: literal quoted PASS: bytevectors.test: Datum Syntax: incorrect prefix PASS: bytevectors.test: Datum Syntax: extraneous space PASS: bytevectors.test: Datum Syntax: negative integers PASS: bytevectors.test: Datum Syntax: out-of-range integers PASS: bytevectors.test: Generalized Vectors: generalized-vector? PASS: bytevectors.test: Generalized Vectors: generalized-vector-length PASS: bytevectors.test: Generalized Vectors: generalized-vector-ref PASS: bytevectors.test: Generalized Vectors: generalized-vector-ref [index = out-of-range] PASS: bytevectors.test: Generalized Vectors: generalized-vector-set! PASS: bytevectors.test: Generalized Vectors: generalized-vector-set! [index= out-of-range] PASS: bytevectors.test: Generalized Vectors: generalized-vector-set! [value= out-of-range] PASS: bytevectors.test: Generalized Vectors: array-type PASS: bytevectors.test: Generalized Vectors: array-contents PASS: bytevectors.test: Generalized Vectors: array-ref PASS: bytevectors.test: Generalized Vectors: array-set! PASS: bytevectors.test: Generalized Vectors: make-typed-array PASS: bytevectors.test: Generalized Vectors: make-typed-array [out-of-range] PASS: bytevectors.test: uniform-array->bytevector: bytevector PASS: bytevectors.test: uniform-array->bytevector: empty bitvector PASS: bytevectors.test: uniform-array->bytevector: bitvector < 8 PASS: bytevectors.test: uniform-array->bytevector: bitvector =3D=3D 8 PASS: bytevectors.test: uniform-array->bytevector: bitvector > 8 PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/fports.c PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/strports.c PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/backtrace.c PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/ioext.c PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/r6rs-ports.c PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/ports.c PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/read.c PASS: c-api.test: SEEK_XXX =3D> #include : /home/german/Descargas= /guile-2.0.5.128-e9c89/libguile/gdbint.c PASS: chars.test: basic char handling: evaluator: evaluating chars PASS: chars.test: basic char handling: comparisons: char=3D? #\A #\A XFAIL: chars.test: basic char handling: comparisons: char=3D? #\A #\a XFAIL: chars.test: basic char handling: comparisons: char=3D? #\A #\B XFAIL: chars.test: basic char handling: comparisons: char=3D? #\B #\A XFAIL: chars.test: basic char handling: comparisons: char? #\A #\A XFAIL: chars.test: basic char handling: comparisons: char>? #\A #\a XFAIL: chars.test: basic char handling: comparisons: char>? #\A #\B PASS: chars.test: basic char handling: comparisons: char>? #\B #\A PASS: chars.test: basic char handling: comparisons: char>=3D? #\A #\A XFAIL: chars.test: basic char handling: comparisons: char>=3D? #\A #\a XFAIL: chars.test: basic char handling: comparisons: char>=3D? #\A #\B PASS: chars.test: basic char handling: comparisons: char>=3D? #\B #\A PASS: chars.test: basic char handling: comparisons: char-ci=3D? #\A #\A PASS: chars.test: basic char handling: comparisons: char-ci=3D? #\A #\a XFAIL: chars.test: basic char handling: comparisons: char-ci=3D? #\A #\B XFAIL: chars.test: basic char handling: comparisons: char-ci=3D? #\B #\A XFAIL: chars.test: basic char handling: comparisons: char-ci? #\A #\A XFAIL: chars.test: basic char handling: comparisons: char-ci>? #\A #\a XFAIL: chars.test: basic char handling: comparisons: char-ci>? #\A #\B PASS: chars.test: basic char handling: comparisons: char-ci>? #\B #\A PASS: chars.test: basic char handling: comparisons: char-ci>=3D? #\A #\A PASS: chars.test: basic char handling: comparisons: char-ci>=3D? #\A #\a XFAIL: chars.test: basic char handling: comparisons: char-ci>=3D? #\A #\B PASS: chars.test: basic char handling: comparisons: char-ci>=3D? #\B #\A PASS: chars.test: basic char handling: categories: char-alphabetic? PASS: chars.test: basic char handling: categories: char-numeric? PASS: chars.test: basic char handling: categories: char-whitespace? PASS: chars.test: basic char handling: categories: char-upper-case? PASS: chars.test: basic char handling: categories: char-lower-case? PASS: chars.test: basic char handling: categories: char-is-both? works PASS: chars.test: basic char handling: categories: char-general-category PASS: chars.test: basic char handling: integer: char->integer PASS: chars.test: basic char handling: integer: integer->char PASS: chars.test: basic char handling: integer: integer->char out of range,= -1 PASS: chars.test: basic char handling: integer: integer->char out of range,= surrrogate PASS: chars.test: basic char handling: integer: integer->char out of range,= too big PASS: chars.test: basic char handling: integer: octal out of range, surrrog= ate PASS: chars.test: basic char handling: integer: octal out of range, too big PASS: chars.test: basic char handling: case: char-upcase PASS: chars.test: basic char handling: case: char-downcase PASS: chars.test: basic char handling: case: char-titlecase PASS: chars.test: basic char handling: charnames: R5RS character names PASS: chars.test: basic char handling: charnames: R6RS character names PASS: chars.test: basic char handling: charnames: R5RS character names are = case insensitive PASS: chars.test: basic char handling: charnames: C0 control names are case= insensitive PASS: chars.test: basic char handling: charnames: alt charnames are case in= sensitive PASS: chars.test: basic char handling: charnames: bad charname PASS: chars.test: basic char handling: charnames: R5RS character names are = preferred write format PASS: chars.test: basic char handling: charnames: C0 control character name= s are preferred write format PASS: chars.test: basic char handling: charnames: combining accent is prett= y-printed PASS: chars.test: basic char handling: charnames: combining X is pretty-pri= nted PASS: coding.test: block comments: first line PASS: coding.test: block comments: first line no whitespace PASS: coding.test: block comments: second line PASS: coding.test: block comments: second line no whitespace PASS: coding.test: block comments: third line PASS: coding.test: block comments: third line no whitespace PASS: coding.test: line comments: first line, no whitespace, no nl PASS: coding.test: line comments: first line, whitespace, no nl PASS: coding.test: line comments: first line, no whitespace, nl PASS: coding.test: line comments: first line, whitespace, nl PASS: coding.test: line comments: second line, no whitespace, no nl PASS: coding.test: line comments: second line, whitespace, no nl PASS: coding.test: line comments: second line, no whitespace, nl PASS: coding.test: line comments: second line, whitespace, nl PASS: common-list.test: intersection: documented? PASS: common-list.test: intersection: both arguments empty PASS: common-list.test: intersection: first argument empty PASS: common-list.test: intersection: second argument empty PASS: common-list.test: intersection: disjoint arguments PASS: common-list.test: intersection: equal arguments PASS: common-list.test: intersection: reverse argument order PASS: common-list.test: intersection: multiple matches in first list PASS: common-list.test: intersection: multiple matches in second list PASS: common-list.test: intersection: mixed arguments PASS: common-list.test: set-difference: documented? PASS: common-list.test: set-difference: both arguments empty PASS: common-list.test: set-difference: first argument empty PASS: common-list.test: set-difference: second argument empty PASS: common-list.test: set-difference: disjoint arguments PASS: common-list.test: set-difference: equal arguments PASS: common-list.test: set-difference: reverse argument order PASS: common-list.test: set-difference: multiple matches in first list PASS: common-list.test: set-difference: multiple matches in second list PASS: common-list.test: set-difference: mixed arguments PASS: common-list.test: remove-if: documented? PASS: common-list.test: remove-if: empty list, remove all PASS: common-list.test: remove-if: empty list, remove none PASS: common-list.test: remove-if: non-empty list, remove all PASS: common-list.test: remove-if: non-empty list, remove none PASS: common-list.test: remove-if: non-empty list, remove some PASS: common-list.test: remove-if-not: documented? PASS: common-list.test: remove-if-not: empty list, remove all PASS: common-list.test: remove-if-not: empty list, remove none PASS: common-list.test: remove-if-not: non-empty list, remove all PASS: common-list.test: remove-if-not: non-empty list, remove none PASS: common-list.test: remove-if-not: non-empty list, remove some PASS: common-list.test: delete-if!: documented? PASS: common-list.test: delete-if!: empty list, remove all PASS: common-list.test: delete-if!: empty list, remove none PASS: common-list.test: delete-if!: non-empty list, remove all PASS: common-list.test: delete-if!: non-empty list, remove none PASS: common-list.test: delete-if!: non-empty list, remove some PASS: common-list.test: delete-if-not!: documented? PASS: common-list.test: delete-if-not!: empty list, remove all PASS: common-list.test: delete-if-not!: empty list, remove none PASS: common-list.test: delete-if-not!: non-empty list, remove all PASS: common-list.test: delete-if-not!: non-empty list, remove none PASS: common-list.test: delete-if-not!: non-empty list, remove some PASS: continuations.test: continuations: throwing to a rewound catch context PASS: continuations.test: continuations: can print a continuation PASS: continuations.test: continuations: blocked attempt to cross a continu= ation barrier PASS: continuations.test: continuations: uncaught exception is handled by c= ontinuation barrier PASS: continuations.test: continuations: exit unwinds dynwinds inside a con= tinuation barrier PASS: continuations.test: continuations: make a stack from a continuation PASS: continuations.test: continuations: get a continuation's stack ID PASS: control.test: escape-only continuations: no values, normal exit (eval) PASS: control.test: escape-only continuations: no values, normal exit (comp= ile) PASS: control.test: escape-only continuations: no values, abnormal exit (ev= al) PASS: control.test: escape-only continuations: no values, abnormal exit (co= mpile) PASS: control.test: escape-only continuations: single value, normal exit (e= val) PASS: control.test: escape-only continuations: single value, normal exit (c= ompile) PASS: control.test: escape-only continuations: single value, abnormal exit = (eval) PASS: control.test: escape-only continuations: single value, abnormal exit = (compile) PASS: control.test: escape-only continuations: multiple values, normal exit= (eval) PASS: control.test: escape-only continuations: multiple values, normal exit= (compile) PASS: control.test: escape-only continuations: multiple values, abnormal ex= it (eval) PASS: control.test: escape-only continuations: multiple values, abnormal ex= it (compile) PASS: control.test: reified continuations: no values, normal exit (eval) PASS: control.test: reified continuations: no values, normal exit (compile) PASS: control.test: reified continuations: no values, abnormal exit (eval) PASS: control.test: reified continuations: no values, abnormal exit (compil= e) PASS: control.test: reified continuations: single value, normal exit (eval) PASS: control.test: reified continuations: single value, normal exit (compi= le) PASS: control.test: reified continuations: single value, abnormal exit (eva= l) PASS: control.test: reified continuations: single value, abnormal exit (com= pile) PASS: control.test: reified continuations: multiple values, normal exit (ev= al) PASS: control.test: reified continuations: multiple values, normal exit (co= mpile) PASS: control.test: reified continuations: multiple values, abnormal exit (= eval) PASS: control.test: reified continuations: multiple values, abnormal exit (= compile) PASS: control.test: reified continuations: reified pending call frames, ins= tantiated elsewhere on the stack (eval) PASS: control.test: reified continuations: reified pending call frames, ins= tantiated elsewhere on the stack (compile) PASS: control.test: restarting partial continuations: in side-effect positi= on (eval) PASS: control.test: restarting partial continuations: in side-effect positi= on (compile) PASS: control.test: restarting partial continuations: passing values to sid= e-effect abort (eval) PASS: control.test: restarting partial continuations: passing values to sid= e-effect abort (compile) PASS: control.test: restarting partial continuations: called for one value = (eval) PASS: control.test: restarting partial continuations: called for one value = (compile) PASS: control.test: restarting partial continuations: called for multiple v= alues (eval) PASS: control.test: restarting partial continuations: called for multiple v= alues (compile) PASS: control.test: restarting partial continuations: in tail position (eva= l) PASS: control.test: restarting partial continuations: in tail position (com= pile) PASS: control.test: prompt in different contexts: push, normal exit (eval) PASS: control.test: prompt in different contexts: push, normal exit (compil= e) PASS: control.test: prompt in different contexts: push, nonlocal exit (eval) PASS: control.test: prompt in different contexts: push, nonlocal exit (comp= ile) PASS: control.test: prompt in different contexts: push with RA, normal exit= (eval) PASS: control.test: prompt in different contexts: push with RA, normal exit= (compile) PASS: control.test: prompt in different contexts: push with RA, nonlocal ex= it (eval) PASS: control.test: prompt in different contexts: push with RA, nonlocal ex= it (compile) PASS: control.test: prompt in different contexts: tail, normal exit (eval) PASS: control.test: prompt in different contexts: tail, normal exit (compil= e) PASS: control.test: prompt in different contexts: tail, nonlocal exit (eval) PASS: control.test: prompt in different contexts: tail, nonlocal exit (comp= ile) PASS: control.test: prompt in different contexts: tail with RA, normal exit= (eval) PASS: control.test: prompt in different contexts: tail with RA, normal exit= (compile) PASS: control.test: prompt in different contexts: tail with RA, nonlocal ex= it (eval) PASS: control.test: prompt in different contexts: tail with RA, nonlocal ex= it (compile) PASS: control.test: prompt in different contexts: drop, normal exit (eval) PASS: control.test: prompt in different contexts: drop, normal exit (compil= e) PASS: control.test: prompt in different contexts: drop, nonlocal exit (eval) PASS: control.test: prompt in different contexts: drop, nonlocal exit (comp= ile) PASS: control.test: prompt in different contexts: drop with RA, normal exit= (eval) PASS: control.test: prompt in different contexts: drop with RA, normal exit= (compile) PASS: control.test: prompt in different contexts: drop with RA, nonlocal ex= it (eval) PASS: control.test: prompt in different contexts: drop with RA, nonlocal ex= it (compile) PASS: control.test: suspend/resume with fluids: normal PASS: control.test: suspend/resume with fluids: with-fluids normal PASS: control.test: suspend/resume with fluids: normal (post) PASS: control.test: suspend/resume with fluids: with-fluids and fluid-set! PASS: control.test: suspend/resume with fluids: normal (post2) PASS: control.test: suspend/resume with fluids: normal fluid-set! PASS: control.test: suspend/resume with fluids: reset fluid-set! PASS: control.test: suspend/resume with fluids: pre PASS: control.test: suspend/resume with fluids: res PASS: control.test: suspend/resume with fluids: post PASS: control.test: rewinding prompts: nested prompts (eval) PASS: control.test: rewinding prompts: nested prompts (compile) PASS: control.test: abort to unknown prompt: foo (eval) PASS: control.test: abort to unknown prompt: foo (compile) PASS: control.test: the-vm: unwind changes VMs (eval) PASS: control.test: the-vm: unwind changes VMs (compile) PASS: control.test: shift and reset: (equal? 117 (+ 10 (reset (+ 2 (shift k= (+ 100 (k (k 3)))))))) PASS: control.test: shift and reset: (equal? 60 (* 10 (reset (* 2 (shift g = (* 5 (shift f (+ (f 1) 1)))))))) PASS: control.test: shift and reset: (equal? 121 (let ((f (lambda (x) (shif= t k (k (k x)))))) (+ 1 (reset (+ 10 (f 100)))))) PASS: control.test: shift and reset: (equal? (quote a) (car (reset (let ((x= (shift f (shift f1 (f1 (cons (quote a) (f (quote ())))))))) (shift g x))))) PASS: control.test: shift and reset: (equal? (quote (1 2 3 4 5)) (let () (d= efine (traverse xs) (define (visit xs) (if (null? xs) (quote ()) (visit (sh= ift* (lambda (k) (cons (car xs) (k (cdr xs)))))))) (reset* (lambda () (visi= t xs)))) (traverse (quote (1 2 3 4 5))))) PASS: coverage.test: instrumented/executed-lines: instr =3D exec PASS: coverage.test: instrumented/executed-lines: instr >=3D exec PASS: coverage.test: line-execution-counts: once PASS: coverage.test: line-execution-counts: several times PASS: coverage.test: line-execution-counts: some PASS: coverage.test: line-execution-counts: one proc hit, one proc unused PASS: coverage.test: line-execution-counts: case-lambda PASS: coverage.test: line-execution-counts: all code on one line PASS: coverage.test: procedure-execution-count: several times PASS: coverage.test: procedure-execution-count: case-lambda PASS: coverage.test: procedure-execution-count: never PASS: coverage.test: procedure-execution-count: called from C PASS: coverage.test: procedure-execution-count: called from eval PASS: coverage.test: instrumented-source-files: source files are listed as = expected PASS: cse.test: cse: (lambda (x y) (and (eq? x y) (eq? x y))) PASS: cse.test: cse: (lambda (x y) (if (eq? x y) #f #t)) PASS: cse.test: cse: (lambda (x y) (and (eq? x y) (not (eq? x y)))) PASS: cse.test: cse: (lambda (x y) (if (eq? x y) #f (eq? x y))) PASS: cse.test: cse: (lambda (x y) (and (set-car! x y) (not (set-car! x y))= )) PASS: cse.test: cse: (lambda (x y) (and (string-ref x y) (begin (string-ref= x y) (not (string-ref x y))))) PASS: cse.test: cse: (lambda (x y) (and (string-ref x y) (lambda () (and (s= tring-ref x y) #t)))) PASS: cse.test: cse: (lambda (x y) (and (string-ref x y) (begin (string-set= ! x !) (not (string-ref x y))))) PASS: cse.test: cse: (lambda (x y) (begin (eq? x y) (eq? x y))) PASS: cse.test: cse: (lambda (x y) (begin (unless (eq? x y) (throw (quote f= oo))) (eq? x y))) PASS: cse.test: cse: (lambda (x y) (begin (unless (and (struct? x) (eq? (st= ruct-vtable x) x-vtable)) (throw (quote foo))) (if (and (struct? x) (eq? (s= truct-vtable x) x-vtable)) (struct-ref x y) (throw (quote bar))))) PASS: cse.test: cse: (lambda (x) ((lambda (z) (+ z (if (and (struct? x) (eq= ? (struct-vtable x) x-vtable)) (struct-ref x 2) (throw (quote bar))))) (if = (and (struct? x) (eq? (struct-vtable x) x-vtable)) (struct-ref x 1) (throw = (quote foo))))) PASS: cse.test: cse: (let ((x (car y))) (cons x (car y))) PASS: curried-definitions.test: define: define works as usual PASS: curried-definitions.test: define: define works as usual (2) PASS: curried-definitions.test: define: currying once PASS: curried-definitions.test: define: currying twice PASS: curried-definitions.test: define: just a value PASS: curried-definitions.test: define*: define* works as usual PASS: curried-definitions.test: define*: define* works as usual (2) PASS: curried-definitions.test: define*: currying once PASS: curried-definitions.test: define*: currying twice PASS: curried-definitions.test: define*: just a value PASS: ecmascript.test: parser: true; PASS: ecmascript.test: parser: true; PASS: ecmascript.test: parser: 2 + 2; PASS: ecmascript.test: parser: 2 + 2; PASS: ecmascript.test: parser: 2=C2=A0+2; PASS: ecmascript.test: parser: 2=C2=A0+2; PASS: ecmascript.test: parser: "hello"; PASS: ecmascript.test: parser: "hello"; PASS: ecmascript.test: parser: function square(x) { return x * x; } PASS: ecmascript.test: parser: function square(x) { return x * x; } PASS: ecmascript.test: parser: document.write('Hello, world!'); PASS: ecmascript.test: parser: document.write('Hello, world!'); PASS: ecmascript.test: parser: var x =3D { foo: 12, bar: "hello" }; PASS: ecmascript.test: parser: var x =3D { foo: 12, bar: "hello" }; PASS: ecmascript.test: parser: "\x12"; PASS: ecmascript.test: parser: "\x12"; PASS: ecmascript.test: parser: "\u1234"; PASS: ecmascript.test: parser: "\u1234"; PASS: ecmascript.test: parser: function foo(x) { } PASS: ecmascript.test: parser: function foo(x) { } PASS: ecmascript.test: parser: .123; PASS: ecmascript.test: parser: .123; PASS: ecmascript.test: parser: 0xff; PASS: ecmascript.test: parser: 0xff; PASS: ecmascript.test: compiler: true; PASS: ecmascript.test: compiler: 2 + 2; PASS: ecmascript.test: compiler: "hello"; PASS: ecmascript.test: compiler: var test =3D { bar: 1 }; PASS: ecmascript.test: compiler: 42 + " good times!"; PASS: ecmascript.test: compiler: [0,1,2,3,4,5].length * 7; PASS: elisp-compiler.test: Sequencing: progn PASS: elisp-compiler.test: Sequencing: prog1 PASS: elisp-compiler.test: Sequencing: prog2 PASS: elisp-compiler.test: Conditionals: succeeding if PASS: elisp-compiler.test: Conditionals: failing if PASS: elisp-compiler.test: Conditionals: failing when PASS: elisp-compiler.test: Conditionals: succeeding when PASS: elisp-compiler.test: Conditionals: failing unless PASS: elisp-compiler.test: Conditionals: succeeding unless PASS: elisp-compiler.test: Conditionals: empty cond PASS: elisp-compiler.test: Conditionals: all failing cond PASS: elisp-compiler.test: Conditionals: only condition PASS: elisp-compiler.test: Conditionals: succeeding cond value PASS: elisp-compiler.test: Conditionals: succeeding cond side-effect PASS: elisp-compiler.test: Combining Conditions: empty and PASS: elisp-compiler.test: Combining Conditions: failing and PASS: elisp-compiler.test: Combining Conditions: succeeding and PASS: elisp-compiler.test: Combining Conditions: empty or PASS: elisp-compiler.test: Combining Conditions: failing or PASS: elisp-compiler.test: Combining Conditions: succeeding or PASS: elisp-compiler.test: Combining Conditions: not true PASS: elisp-compiler.test: Combining Conditions: not false PASS: elisp-compiler.test: Iteration: failing while PASS: elisp-compiler.test: Iteration: running while PASS: elisp-compiler.test: Iteration: dotimes PASS: elisp-compiler.test: Iteration: dolist PASS: elisp-compiler.test: Exceptions: catch without exception UNRESOLVED: elisp-compiler.test: Exceptions: catch and throw UNRESOLVED: elisp-compiler.test: Exceptions: unwind-protect PASS: elisp-compiler.test: Eval: basic eval PASS: elisp-compiler.test: Eval: real dynamic code PASS: elisp-compiler.test: Eval: recursive eval PASS: elisp-compiler.test: Variable Setting/Referencing: setq and reference PASS: elisp-compiler.test: Variable Setting/Referencing: setq evaluation or= der PASS: elisp-compiler.test: Variable Setting/Referencing: setq value PASS: elisp-compiler.test: Variable Setting/Referencing: set and symbol-val= ue PASS: elisp-compiler.test: Variable Setting/Referencing: void variables PASS: elisp-compiler.test: Let and Let*: let without value PASS: elisp-compiler.test: Let and Let*: basic let PASS: elisp-compiler.test: Let and Let*: let* PASS: elisp-compiler.test: Let and Let*: local scope PASS: elisp-compiler.test: Lexical Scoping: basic let semantics PASS: elisp-compiler.test: Lexical Scoping: lexical scope with lexical-let's PASS: elisp-compiler.test: Lexical Scoping: lexical scoping vs. symbol-valu= e / set PASS: elisp-compiler.test: Lexical Scoping: let inside lexical-let PASS: elisp-compiler.test: Lexical Scoping: lambda args inside lexical-let PASS: elisp-compiler.test: Lexical Scoping: closures PASS: elisp-compiler.test: Lexical Scoping: always lexical option (all) PASS: elisp-compiler.test: Lexical Scoping: always lexical option (list) PASS: elisp-compiler.test: Lexical Scoping: with-always-lexical PASS: elisp-compiler.test: Lexical Scoping: lexical lambda args PASS: elisp-compiler.test: Lexical Scoping: lexical lambda tail-recursion PASS: elisp-compiler.test: defconst and defvar: defconst without docstring PASS: elisp-compiler.test: defconst and defvar: defconst value PASS: elisp-compiler.test: defconst and defvar: defvar without value PASS: elisp-compiler.test: defconst and defvar: defvar on already defined v= ariable PASS: elisp-compiler.test: defconst and defvar: defvar on undefined variable PASS: elisp-compiler.test: defconst and defvar: defvar value PASS: elisp-compiler.test: Lambda Expressions: required arguments PASS: elisp-compiler.test: Lambda Expressions: optional argument PASS: elisp-compiler.test: Lambda Expressions: optional missing PASS: elisp-compiler.test: Lambda Expressions: rest argument PASS: elisp-compiler.test: Lambda Expressions: rest missing PASS: elisp-compiler.test: Function Definitions: defun PASS: elisp-compiler.test: Function Definitions: defun value PASS: elisp-compiler.test: Function Definitions: fset and symbol-function PASS: elisp-compiler.test: Function Definitions: void function values PASS: elisp-compiler.test: Function Definitions: flet and flet* PASS: elisp-compiler.test: Calling Functions: recursion PASS: elisp-compiler.test: Calling Functions: dynamic scoping PASS: elisp-compiler.test: Calling Functions: funcall and apply argument ha= ndling PASS: elisp-compiler.test: Calling Functions: raw functions with funcall PASS: elisp-compiler.test: Quotation: quote PASS: elisp-compiler.test: Quotation: simple backquote PASS: elisp-compiler.test: Quotation: unquote PASS: elisp-compiler.test: Quotation: unquote splicing PASS: elisp-compiler.test: Macros: defmacro value PASS: elisp-compiler.test: Macros: macro expansion PASS: elisp-compiler.test: Equivalence Predicates: equal UNRESOLVED: elisp-compiler.test: Equivalence Predicates: eq PASS: elisp-compiler.test: Number Built-Ins: floatp PASS: elisp-compiler.test: Number Built-Ins: integerp PASS: elisp-compiler.test: Number Built-Ins: numberp PASS: elisp-compiler.test: Number Built-Ins: wholenump PASS: elisp-compiler.test: Number Built-Ins: zerop PASS: elisp-compiler.test: Number Built-Ins: comparisons PASS: elisp-compiler.test: Number Built-Ins: max and min PASS: elisp-compiler.test: Number Built-Ins: abs PASS: elisp-compiler.test: Number Built-Ins: float PASS: elisp-compiler.test: Number Built-Ins: basic arithmetic operators PASS: elisp-compiler.test: Number Built-Ins: modulo PASS: elisp-compiler.test: Number Built-Ins: floating point rounding PASS: elisp-compiler.test: List Built-Ins: consp and atomp PASS: elisp-compiler.test: List Built-Ins: listp and nlistp PASS: elisp-compiler.test: List Built-Ins: null PASS: elisp-compiler.test: List Built-Ins: car and cdr PASS: elisp-compiler.test: List Built-Ins: car-safe and cdr-safe PASS: elisp-compiler.test: List Built-Ins: pop PASS: elisp-compiler.test: List Built-Ins: push PASS: elisp-compiler.test: List Built-Ins: nth and nthcdr PASS: elisp-compiler.test: List Built-Ins: length PASS: elisp-compiler.test: List Built-Ins: cons, list and make-list PASS: elisp-compiler.test: List Built-Ins: append PASS: elisp-compiler.test: List Built-Ins: reverse PASS: elisp-compiler.test: List Built-Ins: copy-tree PASS: elisp-compiler.test: List Built-Ins: number-sequence PASS: elisp-compiler.test: List Built-Ins: setcar and setcdr PASS: elisp-reader.test: Lexer: end-of-input PASS: elisp-reader.test: Lexer: single character tokens PASS: elisp-reader.test: Lexer: whitespace and comments PASS: elisp-reader.test: Lexer: source properties PASS: elisp-reader.test: Lexer: symbols PASS: elisp-reader.test: Lexer: integers PASS: elisp-reader.test: Lexer: floats PASS: elisp-reader.test: Lexer: strings PASS: elisp-reader.test: Lexer: ASCII control characters and meta in strings PASS: elisp-reader.test: Lexer: characters PASS: elisp-reader.test: Lexer: meta characters PASS: elisp-reader.test: Lexer: circular markers PASS: elisp-reader.test: Lexer: lexer/1 PASS: elisp-reader.test: Parser: only next expression PASS: elisp-reader.test: Parser: source properties PASS: elisp-reader.test: Parser: constants PASS: elisp-reader.test: Parser: quotation PASS: elisp-reader.test: Parser: lists PASS: elisp-reader.test: Parser: vectors PASS: elisp-reader.test: Parser: circular structures PASS: elisp.test: scheme: nil value is a boolean: boolean? PASS: elisp.test: scheme: nil value is false: not PASS: elisp.test: scheme: nil value is false: if PASS: elisp.test: scheme: nil value is false: and PASS: elisp.test: scheme: nil value is false: or PASS: elisp.test: scheme: nil value is false: cond PASS: elisp.test: scheme: nil value is false: do PASS: elisp.test: scheme: nil value as an empty list: list? PASS: elisp.test: scheme: nil value as an empty list: null? PASS: elisp.test: scheme: nil value as an empty list: sort PASS: elisp.test: scheme: lists formed using nil value: list? PASS: elisp.test: scheme: lists formed using nil value: length of #nil PASS: elisp.test: scheme: lists formed using nil value: length PASS: elisp.test: scheme: lists formed using nil value: length (with backqu= oted list) PASS: elisp.test: scheme: lists formed using nil value: write (#nil) PASS: elisp.test: scheme: lists formed using nil value: display (#nil) PASS: elisp.test: scheme: lists formed using nil value: write (list) PASS: elisp.test: scheme: lists formed using nil value: display (list) PASS: elisp.test: scheme: lists formed using nil value: assq PASS: elisp.test: scheme: lists formed using nil value: assv PASS: elisp.test: scheme: lists formed using nil value: assoc PASS: elisp.test: scheme: lists formed using nil value: with-fluids* PASS: elisp.test: scheme: lists formed using nil value: append! PASS: elisp.test: scheme: lists formed using nil value: last-pair PASS: elisp.test: scheme: lists formed using nil value: reverse PASS: elisp.test: scheme: lists formed using nil value: reverse! PASS: elisp.test: scheme: lists formed using nil value: list-ref PASS: elisp.test: scheme: lists formed using nil value: list-ref PASS: elisp.test: scheme: lists formed using nil value: list-set! PASS: elisp.test: scheme: lists formed using nil value: list-set! PASS: elisp.test: scheme: lists formed using nil value: list-cdr-set! PASS: elisp.test: scheme: lists formed using nil value: list-cdr-set! PASS: elisp.test: scheme: lists formed using nil value: memq PASS: elisp.test: scheme: lists formed using nil value: memv PASS: elisp.test: scheme: lists formed using nil value: member PASS: elisp.test: scheme: lists formed using nil value: list->vector PASS: elisp.test: scheme: lists formed using nil value: list->vector PASS: elisp.test: scheme: lists formed using nil value: list->weak-vector PASS: elisp.test: scheme: lists formed using nil value: sorted? PASS: elisp.test: scheme: lists formed using nil value: merge PASS: elisp.test: scheme: lists formed using nil value: merge! PASS: elisp.test: scheme: lists formed using nil value: sort PASS: elisp.test: scheme: lists formed using nil value: stable-sort PASS: elisp.test: scheme: lists formed using nil value: sort! PASS: elisp.test: scheme: lists formed using nil value: stable-sort! PASS: elisp.test: scheme: value preservation: car PASS: elisp.test: scheme: value preservation: cdr PASS: elisp.test: scheme: value preservation: vector-ref PASS: elisp.test: elisp: (and #f) PASS: elisp.test: elisp: (and #t) PASS: elisp.test: elisp: (and nil) PASS: elisp.test: elisp: (and t) PASS: elisp.test: elisp: (and) PASS: elisp.test: elisp: (cond (nil t) (t 3)) PASS: elisp.test: elisp: (cond (nil t) (t)) PASS: elisp.test: elisp: (cond (nil)) PASS: elisp.test: elisp: (cond) PASS: elisp.test: elisp: (if #f (quote a) (quote b)) PASS: elisp.test: elisp: (if #t (quote a) (quote b)) PASS: elisp.test: elisp: (if nil (quote a) (quote b)) PASS: elisp.test: elisp: (if nil 1 2 3 4) PASS: elisp.test: elisp: (if nil 1 2) PASS: elisp.test: elisp: (if nil 1) PASS: elisp.test: elisp: (if t 1 2) PASS: elisp.test: elisp: (if t 1) PASS: elisp.test: elisp: (let (a) a) PASS: elisp.test: elisp: (let* (a) a) PASS: elisp.test: elisp: (let* ((a 1) (b (* a 2))) b) PASS: elisp.test: elisp: (null nil) PASS: elisp.test: elisp: (or 1 2 3) PASS: elisp.test: elisp: (or nil t nil) PASS: elisp.test: elisp: (or nil) PASS: elisp.test: elisp: (or t nil t) PASS: elisp.test: elisp: (or t) PASS: elisp.test: elisp: (or) PASS: elisp.test: elisp: (prog1 1 2 3) PASS: elisp.test: elisp: (prog2 1 2 3) PASS: elisp.test: elisp: (progn 1 2 3) PASS: elisp.test: elisp: (while nil 1) PASS: elisp.test: elisp: (defun testf (x y &optional o &rest r) (list x y o= r)) PASS: elisp.test: elisp: (testf 1 2) PASS: elisp.test: elisp: (testf 1 2 3 4 5 56) PASS: elisp.test: elisp: (funcall (lambda (x y &optional o &rest r) (list x= y o r)) 1 2 3 4) PASS: elisp.test: elisp: (apply (lambda (x y &optional o &rest r) (list x y= o r)) 1 2 3 nil) PASS: elisp.test: elisp: (setq x 3) PASS: elisp.test: elisp: (defvar x 4) PASS: elisp.test: elisp: x PASS: eval-string.test: basic: eval none PASS: eval-string.test: basic: eval single PASS: eval-string.test: basic: eval multiple PASS: eval-string.test: basic: compile none PASS: eval-string.test: basic: compile single PASS: eval-string.test: basic: compile multiple PASS: eval-string.test: basic: eval values PASS: eval-string.test: basic: compile values PASS: eval.test: memoization: copy-tree: (#t . #(#t)) PASS: eval.test: memoization: copy-tree: circular lists in forms PASS: eval.test: memoization: transparency PASS: eval.test: evaluator: definitions return # PASS: eval.test: evaluator: symbol lookup: top level: unbound: variable ref= erence PASS: eval.test: evaluator: symbol lookup: top level: unbound: procedure PASS: eval.test: evaluator: parameter error: macro as argument PASS: eval.test: evaluator: parameter error: passing macro as parameter PASS: eval.test: call: wrong number of arguments: ((lambda () #f) 1) PASS: eval.test: call: wrong number of arguments: ((lambda (x) #f)) PASS: eval.test: call: wrong number of arguments: ((lambda (x) #f) 1 2) PASS: eval.test: call: wrong number of arguments: ((lambda (x y) #f)) PASS: eval.test: call: wrong number of arguments: ((lambda (x y) #f) 1) PASS: eval.test: call: wrong number of arguments: ((lambda (x y) #f) 1 2 3) PASS: eval.test: call: wrong number of arguments: ((lambda (x . rest) #f)) PASS: eval.test: call: wrong number of arguments: ((lambda (x y . rest) #f)) PASS: eval.test: call: wrong number of arguments: ((lambda (x y . rest) #f)= 1) PASS: eval.test: apply: scm_tc7_subr_2o: 0 args PASS: eval.test: apply: scm_tc7_subr_2o: 1 arg PASS: eval.test: apply: scm_tc7_subr_2o: 2 args PASS: eval.test: apply: scm_tc7_subr_2o: 3 args XFAIL: eval.test: map: documented? PASS: eval.test: map: argument error: different length lists: first list em= pty PASS: eval.test: map: argument error: different length lists: second list e= mpty PASS: eval.test: map: argument error: different length lists: first list sh= orter PASS: eval.test: map: argument error: different length lists: second list s= horter PASS: eval.test: define set procedure-name: closure XFAIL: eval.test: define set procedure-name: procedure-with-setter PASS: eval.test: promises: basic promise behaviour: delay gives a promise PASS: eval.test: promises: basic promise behaviour: force evaluates a promi= se PASS: eval.test: promises: basic promise behaviour: a forced promise is a p= romise PASS: eval.test: promises: basic promise behaviour: forcing a forced promis= e works PASS: eval.test: promises: basic promise behaviour: a promise is evaluated = once PASS: eval.test: promises: basic promise behaviour: a promise may call itse= lf PASS: eval.test: promises: basic promise behaviour: a promise carries its e= nvironment UNRESOLVED: eval.test: promises: basic promise behaviour: a forced promise = does not reference its environment PASS: eval.test: promises: extended promise behaviour: forcing a non-promis= e object is not supported PASS: eval.test: promises: extended promise behaviour: unmemoizing a promise PASS: eval.test: stacks: stack involving a primitive PASS: eval.test: stacks: arguments of a primitive stack frame PASS: eval.test: letrec init evaluation: lots of inits calculated in correc= t order PASS: eval.test: values: single value PASS: eval.test: values: call-with-values PASS: eval.test: values: equal? PASS: eval.test: stack overflow: exception raised PASS: eval.test: local evaluation: local-eval PASS: eval.test: local evaluation: local-compile PASS: eval.test: local evaluation: the-environment within a macro PASS: eval.test: local evaluation: capture pattern variables PASS: eval.test: local evaluation: mixed primitive-eval, local-eval and loc= al-compile PASS: exceptions.test: throw/catch: wrong type argument: (throw 1) PASS: exceptions.test: throw/catch: wrong number of arguments: (throw) PASS: exceptions.test: throw/catch: wrong number of arguments: throw 1 / ca= tch 0 PASS: exceptions.test: throw/catch: wrong number of arguments: throw 2 / ca= tch 1 PASS: exceptions.test: throw/catch: wrong number of arguments: throw 1 / ca= tch 2 PASS: exceptions.test: throw/catch: wrong number of arguments: throw 3 / ca= tch 2 PASS: exceptions.test: throw/catch: wrong number of arguments: throw 1 / ca= tch 2+ PASS: exceptions.test: throw/catch: with pre-unwind handler: pre-unwind flu= id state PASS: exceptions.test: throw/catch: normal catch PASS: exceptions.test: throw/catch: catch and with-throw-handler PASS: exceptions.test: throw/catch: catch with rethrowing throw-handler PASS: exceptions.test: throw/catch: catch with pre-unwind handler PASS: exceptions.test: throw/catch: catch with rethrowing pre-unwind handler PASS: exceptions.test: throw/catch: catch with throw handler PASS: exceptions.test: throw/catch: catch with rethrowing throw handler PASS: exceptions.test: throw/catch: effect of with-throw-handler not-unwind= ing on throw to another key PASS: exceptions.test: throw/catch: with-throw-handler chaining PASS: exceptions.test: throw/catch: throw handlers throwing to each other r= ecursively PASS: exceptions.test: throw/catch: throw handler throwing to lexically ins= ide catch PASS: exceptions.test: throw/catch: reuse of same throw handler after lexic= ally inside catch PASS: exceptions.test: throw/catch: again but with two chained throw handle= rs PASS: exceptions.test: false-if-exception: (false-if-exception #t) PASS: exceptions.test: false-if-exception: (not (false-if-exception #f)) PASS: exceptions.test: false-if-exception: (not (false-if-exception (error = xxx))) PASS: filesys.test: copy-file: fd leak when dest unwritable PASS: filesys.test: lstat: normal file PASS: filesys.test: lstat: symlink PASS: filesys.test: opendir: root directory: not empty PASS: filesys.test: opendir: root directory: all entries are strings PASS: filesys.test: stat: filename: size PASS: filesys.test: stat: file descriptor: size PASS: filesys.test: stat: port: size PASS: fluids.test: syntax: with-fluids missing expression PASS: fluids.test: syntax: with-fluids bad bindings PASS: fluids.test: syntax: with-fluids bad bindings PASS: fluids.test: initial fluid values: fluid-ref uninitialized fluid is #f --MP_/zCFpupYXKUZ9reVjPK9fne+--