* bug#11878: [guile-2.0.5] install guile-2.0.5 on debian squeeze 32 bit - 2 tests failed
[not found] <CAHCRas=wo6bkTxzdTqzUe6LjSUZt7ZXX1+TDiPLY_wONo-agNw@mail.gmail.com>
@ 2012-07-08 2:42 ` Bernardo Ezequiel Contreras
2012-09-03 20:42 ` Ludovic Courtès
0 siblings, 1 reply; 4+ messages in thread
From: Bernardo Ezequiel Contreras @ 2012-07-08 2:42 UTC (permalink / raw
To: 11878
[-- Attachment #1.1: Type: text/plain, Size: 590 bytes --]
Steps to reproduce:
- wget ftp://ftp.gnu.org/gnu/guile/guile-2.0.5.tar.gz
- tar -xvf guile-2.0.5.tar.gz
- isntalled required libraries
- cd guile-2.0.5
- BDW_GC_CFLAGS=-L/usr/lib BDW_GC_LIBS=-lgc ./configure
- BDW_GC_CFLAGS=-L/usr/lib BDW_GC_LIBS=-lgc make
- BDW_GC_CFLAGS=-L/usr/lib BDW_GC_LIBS=-lgc make check
- 2 of 27 test failed
FAIL: test-scm-spawn-thread
FAIL: test-pthread-create
SKIP: test-pthread-create-secondary
==================================
2 of 27 tests failed
(1 test was not run)
Please report to bug-guile@gnu.org
==================================
--
Bernardo E.C.
[-- Attachment #1.2: Type: text/html, Size: 891 bytes --]
[-- Attachment #2: check-guile.log --]
[-- Type: text/x-log, Size: 87013 bytes --]
PASS: 00-initial-env.test: goopsless: + wrong type argument: 1st argument string (eval)
PASS: 00-initial-env.test: goopsless: + wrong type argument: 1st argument string (compile)
PASS: 00-initial-env.test: goopsless: + wrong type argument: 2nd argument bool (eval)
PASS: 00-initial-env.test: goopsless: + wrong type argument: 2nd argument bool (compile)
PASS: 00-initial-env.test: goopsless: + wrong type argument: implicit forcing is not supported (eval)
PASS: 00-initial-env.test: goopsless: + wrong type argument: implicit forcing is not supported (compile)
PASS: 00-initial-env.test: goopsless: - wrong type argument: 1st argument string (eval)
PASS: 00-initial-env.test: goopsless: - wrong type argument: 1st argument string (compile)
PASS: 00-initial-env.test: goopsless: - wrong type argument: 2nd argument symbol (eval)
PASS: 00-initial-env.test: goopsless: - wrong type argument: 2nd argument symbol (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? 12345678901234567890123456789))
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 u8)))
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 s16)))
PASS: arrays.test: array?: is short: (eq? #f (typed-array? complex (quote s16)))
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 u32)))
PASS: arrays.test: array?: is ulong: (eq? #f (typed-array? complex (quote u32)))
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 s32)))
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 s32)))
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 (quote 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 (quote s64)))
PASS: arrays.test: array?: is long long: (eq? #f (typed-array? complex (quote s64)))
PASS: arrays.test: array?: is long long: (eq? #f (typed-array? scm (quote s64)))
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 f32)))
PASS: arrays.test: array?: is float: (eq? #f (typed-array? complex (quote f32)))
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 f64)))
PASS: arrays.test: array?: is double: (eq? #f (typed-array? ulong (quote f64)))
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 f64)))
PASS: arrays.test: array?: is double: (eq? #t (typed-array? double (quote f64)))
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 c64)))
PASS: arrays.test: array?: is complex: (eq? #f (typed-array? char (quote c64)))
PASS: arrays.test: array?: is complex: (eq? #f (typed-array? byte (quote c64)))
PASS: arrays.test: array?: is complex: (eq? #f (typed-array? short (quote c64)))
PASS: arrays.test: array?: is complex: (eq? #f (typed-array? ulong (quote c64)))
PASS: arrays.test: array?: is complex: (eq? #f (typed-array? long (quote c64)))
PASS: arrays.test: array?: is complex: (eq? #f (typed-array? longlong (quote c64)))
PASS: arrays.test: array?: is complex: (eq? #f (typed-array? float (quote c64)))
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 425))))) (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-ref (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? (make-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? (load-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? (load-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? (load-symbol foo) #vu8(103 0 0 3 102 111 111))
PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-string æ))
PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (load-string æ) #vu8(102 0 0 1 230))
PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-wide-string λ))
PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (load-wide-string λ) #vu8(107 0 0 4 187 3 0 0))
PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (length (load-program () 3 #f (make-int8 3) (return)))
PASS: asm-to-bytecode.test: compiler: asm-to-bytecode: (compile-equal? (load-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-program () 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? (load-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-kfreebsd-gnu
PASS: asm-to-bytecode.test: cross-compilation: target `i586-pc-gnu0.3' honored
PASS: asm-to-bytecode.test: cross-compilation: target `x86_64-pc-linux-gnu' honored
PASS: asm-to-bytecode.test: cross-compilation: target `powerpc-unknown-linux-gnu' honored
PASS: asm-to-bytecode.test: cross-compilation: target `sparc64-unknown-freebsd8.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 bits starting at 0
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 bits starting at 1
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 bits starting at 2
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 bits starting at 28
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 bits starting at 29
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 bits starting at 30
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit - 1 bits 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 bits starting at 0
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 bits starting at 1
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 bits starting at 2
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 bits starting at 28
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 bits starting at 29
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 bits starting at 30
PASS: bit-operations.test: bit-extract: extract from zero: fixnum-bit + 1 bits 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: (= (ash 1 32) 4294967296)
PASS: bit-operations.test: bitshifts on word boundaries: (= (ash 1 64) 18446744073709551616)
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 brainfuck) #: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=? (eval)
PASS: bytevectors.test: 2.2 General Operations: bytevector=? (compile)
PASS: bytevectors.test: 2.2 General Operations: bytevector-copy! overlapping (eval)
PASS: bytevectors.test: 2.2 General Operations: bytevector-copy! overlapping (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->bytevector (eval)
PASS: bytevectors.test: 2.3 Operations on Bytes and Octets: u8-list->bytevector (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: bytevector->sint-list (eval)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->sint-list (compile)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->uint-list (eval)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->uint-list (compile)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->uint-list [empty] (eval)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->uint-list [empty] (compile)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->sint-list [out-of-range] (eval)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->sint-list [out-of-range] (compile)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->sint-list [off-by-one] (eval)
PASS: bytevectors.test: 2.4 Operations on Integers of Arbitrary Size: bytevector->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-ref (eval)
PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-u16-ref (compile)
PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-ref (eval)
PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-ref (compile)
PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-ref [unaligned] (eval)
PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-s16-ref [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-native-{u16,s16}-{ref,set!} (eval)
PASS: bytevectors.test: 2.5 Operations on 16-Bit Integers: bytevector-native-{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-ref (eval)
PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-u32-ref (compile)
PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-s32-ref (eval)
PASS: bytevectors.test: 2.6 Operations on 32-bit Integers: bytevector-s32-ref (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-ref (eval)
PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-u64-ref (compile)
PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-s64-ref (eval)
PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: bytevector-s64-ref (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 zero (eval)
PASS: bytevectors.test: 2.7 Operations on 64-bit Integers: ref/set! with zero (compile)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-single-native-{ref,set!} (eval)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-single-native-{ref,set!} (compile)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-single-{ref,set!} (eval)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-single-{ref,set!} (compile)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-single-{ref,set!} [unaligned] (eval)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-single-{ref,set!} [unaligned] (compile)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-double-native-{ref,set!} (eval)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-double-native-{ref,set!} (compile)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-ieee-double-{ref,set!} (eval)
PASS: bytevectors.test: 2.8 Operations on IEEE-754 Representations: bytevector-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 == 8
PASS: bytevectors.test: uniform-array->bytevector: bitvector > 8
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/read.c
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/ports.c
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/ioext.c
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/strports.c
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/fports.c
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/backtrace.c
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/r6rs-ports.c
PASS: c-api.test: SEEK_XXX => #include <unistd.h>: /home/vonbecmann/downloads/guile/guile-2.0.5/libguile/gdbint.c
PASS: chars.test: basic char handling: evaluator: evaluating chars
PASS: 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
XFAIL: chars.test: basic char handling: comparisons: char=? #\B #\A
XFAIL: chars.test: basic char handling: comparisons: char<? #\A #\A
PASS: chars.test: basic char handling: comparisons: char<? #\A #\a
PASS: chars.test: basic char handling: comparisons: char<? #\A #\B
XFAIL: chars.test: basic char handling: comparisons: char<? #\B #\A
PASS: chars.test: basic char handling: comparisons: char<=? #\A #\A
PASS: chars.test: basic char handling: comparisons: char<=? #\A #\a
PASS: chars.test: basic char handling: comparisons: char<=? #\A #\B
XFAIL: chars.test: basic char handling: comparisons: char<=? #\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>=? #\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-ci=? #\A #\A
PASS: chars.test: basic char handling: comparisons: char-ci=? #\A #\a
XFAIL: chars.test: basic char handling: comparisons: char-ci=? #\A #\B
XFAIL: chars.test: basic char handling: comparisons: char-ci=? #\B #\A
XFAIL: chars.test: basic char handling: comparisons: char-ci<? #\A #\A
XFAIL: chars.test: basic char handling: comparisons: char-ci<? #\A #\a
PASS: chars.test: basic char handling: comparisons: char-ci<? #\A #\B
XFAIL: chars.test: basic char handling: comparisons: char-ci<? #\B #\A
PASS: chars.test: basic char handling: comparisons: char-ci<=? #\A #\A
PASS: chars.test: basic char handling: comparisons: char-ci<=? #\A #\a
PASS: chars.test: basic char handling: comparisons: char-ci<=? #\A #\B
XFAIL: chars.test: basic char handling: comparisons: char-ci<=? #\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>=? #\A #\A
PASS: 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: 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, surrrogate
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 insensitive
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 names are preferred write format
PASS: chars.test: basic char handling: charnames: combining accent is pretty-printed
PASS: chars.test: basic char handling: charnames: combining X is pretty-printed
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 continuation barrier
PASS: continuations.test: continuations: uncaught exception is handled by continuation barrier
PASS: continuations.test: continuations: exit unwinds dynwinds inside a continuation 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 (compile)
PASS: control.test: escape-only continuations: no values, abnormal exit (eval)
PASS: control.test: escape-only continuations: no values, abnormal exit (compile)
PASS: control.test: escape-only continuations: single value, normal exit (eval)
PASS: control.test: escape-only continuations: single value, normal exit (compile)
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 exit (eval)
PASS: control.test: escape-only continuations: multiple values, abnormal exit (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 (compile)
PASS: control.test: reified continuations: single value, normal exit (eval)
PASS: control.test: reified continuations: single value, normal exit (compile)
PASS: control.test: reified continuations: single value, abnormal exit (eval)
PASS: control.test: reified continuations: single value, abnormal exit (compile)
PASS: control.test: reified continuations: multiple values, normal exit (eval)
PASS: control.test: reified continuations: multiple values, normal exit (compile)
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, instantiated elsewhere on the stack (eval)
PASS: control.test: reified continuations: reified pending call frames, instantiated elsewhere on the stack (compile)
PASS: control.test: restarting partial continuations: in side-effect position (eval)
PASS: control.test: restarting partial continuations: in side-effect position (compile)
PASS: control.test: restarting partial continuations: passing values to side-effect abort (eval)
PASS: control.test: restarting partial continuations: passing values to side-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 values (eval)
PASS: control.test: restarting partial continuations: called for multiple values (compile)
PASS: control.test: restarting partial continuations: in tail position (eval)
PASS: control.test: restarting partial continuations: in tail position (compile)
PASS: control.test: prompt in different contexts: push, normal exit (eval)
PASS: control.test: prompt in different contexts: push, normal exit (compile)
PASS: control.test: prompt in different contexts: push, nonlocal exit (eval)
PASS: control.test: prompt in different contexts: push, nonlocal exit (compile)
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 exit (eval)
PASS: control.test: prompt in different contexts: push with RA, nonlocal exit (compile)
PASS: control.test: prompt in different contexts: tail, normal exit (eval)
PASS: control.test: prompt in different contexts: tail, normal exit (compile)
PASS: control.test: prompt in different contexts: tail, nonlocal exit (eval)
PASS: control.test: prompt in different contexts: tail, nonlocal exit (compile)
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 exit (eval)
PASS: control.test: prompt in different contexts: tail with RA, nonlocal exit (compile)
PASS: control.test: prompt in different contexts: drop, normal exit (eval)
PASS: control.test: prompt in different contexts: drop, normal exit (compile)
PASS: control.test: prompt in different contexts: drop, nonlocal exit (eval)
PASS: control.test: prompt in different contexts: drop, nonlocal exit (compile)
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 exit (eval)
PASS: control.test: prompt in different contexts: drop with RA, nonlocal exit (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) (shift 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 () (define (traverse xs) (define (visit xs) (if (null? xs) (quote ()) (visit (shift* (lambda (k) (cons (car xs) (k (cdr xs)))))))) (reset* (lambda () (visit xs)))) (traverse (quote (1 2 3 4 5)))))
PASS: coverage.test: instrumented/executed-lines: instr = exec
PASS: coverage.test: instrumented/executed-lines: instr >= 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: 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 +2;
PASS: ecmascript.test: parser: 2 +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 = { foo: 12, bar: "hello" };
PASS: ecmascript.test: parser: var x = { 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 = { 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
PASS: 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 order
PASS: elisp-compiler.test: Variable Setting/Referencing: setq value
PASS: elisp-compiler.test: Variable Setting/Referencing: set and symbol-value
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-value / 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 variable
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 handling
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 backquoted 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 #<unspecified>
PASS: eval.test: evaluator: symbol lookup: top level: unbound: variable reference
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 empty
PASS: eval.test: map: argument error: different length lists: second list empty
PASS: eval.test: map: argument error: different length lists: first list shorter
PASS: eval.test: map: argument error: different length lists: second list shorter
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 promise
PASS: eval.test: promises: basic promise behaviour: a forced promise is a promise
PASS: eval.test: promises: basic promise behaviour: forcing a forced promise works
PASS: eval.test: promises: basic promise behaviour: a promise is evaluated once
PASS: eval.test: promises: basic promise behaviour: a promise may call itself
PASS: eval.test: promises: basic promise behaviour: a promise carries its environment
PASS: eval.test: promises: basic promise behaviour: a forced promise does not reference its environment
PASS: eval.test: promises: extended promise behaviour: forcing a non-promise 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 correct 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 local-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 / catch 0
PASS: exceptions.test: throw/catch: wrong number of arguments: throw 2 / catch 1
PASS: exceptions.test: throw/catch: wrong number of arguments: throw 1 / catch 2
PASS: exceptions.test: throw/catch: wrong number of arguments: throw 3 / catch 2
PASS: exceptions.test: throw/catch: wrong number of arguments: throw 1 / catch 2+
PASS: exceptions.test: throw/catch: with pre-unwind handler: pre-unwind fluid 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-unwinding 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 recursively
PASS: exceptions.test: throw/catch: throw handler throwing to lexically inside catch
PASS: exceptions.test: throw/catch: reuse of same throw handler after lexically inside catch
PASS: exceptions.test: throw/catch: again but with two chained throw handlers
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
^ permalink raw reply [flat|nested] 4+ messages in thread
* bug#11878: [guile-2.0.5] install guile-2.0.5 on debian squeeze 32 bit - 2 tests failed
2012-07-08 2:42 ` bug#11878: [guile-2.0.5] install guile-2.0.5 on debian squeeze 32 bit - 2 tests failed Bernardo Ezequiel Contreras
@ 2012-09-03 20:42 ` Ludovic Courtès
2012-09-03 21:51 ` Bernardo Ezequiel Contreras
0 siblings, 1 reply; 4+ messages in thread
From: Ludovic Courtès @ 2012-09-03 20:42 UTC (permalink / raw
To: Bernardo Ezequiel Contreras; +Cc: 11878
Hi Bernardo,
Sorry for the late reply.
Bernardo Ezequiel Contreras <vonbecmann@gmail.com> skribis:
> FAIL: test-scm-spawn-thread
> FAIL: test-pthread-create
What version of libgc do you use? Version 7.1 or higher is recommended.
Thanks,
Ludo’.
^ permalink raw reply [flat|nested] 4+ messages in thread
* bug#11878: [guile-2.0.5] install guile-2.0.5 on debian squeeze 32 bit - 2 tests failed
2012-09-03 20:42 ` Ludovic Courtès
@ 2012-09-03 21:51 ` Bernardo Ezequiel Contreras
2012-09-04 9:42 ` Ludovic Courtès
0 siblings, 1 reply; 4+ messages in thread
From: Bernardo Ezequiel Contreras @ 2012-09-03 21:51 UTC (permalink / raw
To: Ludovic Courtès; +Cc: 11878
[-- Attachment #1: Type: text/plain, Size: 469 bytes --]
Ludo,
you can close this issue. i'm trying with version 2.0.6.
Thanks.
On Mon, Sep 3, 2012 at 5:42 PM, Ludovic Courtès <ludo@gnu.org> wrote:
> Hi Bernardo,
>
> Sorry for the late reply.
>
> Bernardo Ezequiel Contreras <vonbecmann@gmail.com> skribis:
>
> > FAIL: test-scm-spawn-thread
> > FAIL: test-pthread-create
>
> What version of libgc do you use? Version 7.1 or higher is recommended.
>
> Thanks,
> Ludo’.
>
--
Bernardo E.C.
[-- Attachment #2: Type: text/html, Size: 860 bytes --]
^ permalink raw reply [flat|nested] 4+ messages in thread
* bug#11878: [guile-2.0.5] install guile-2.0.5 on debian squeeze 32 bit - 2 tests failed
2012-09-03 21:51 ` Bernardo Ezequiel Contreras
@ 2012-09-04 9:42 ` Ludovic Courtès
0 siblings, 0 replies; 4+ messages in thread
From: Ludovic Courtès @ 2012-09-04 9:42 UTC (permalink / raw
To: Bernardo Ezequiel Contreras; +Cc: 11878-close
Bernardo Ezequiel Contreras <vonbecmann@gmail.com> skribis:
> you can close this issue. i'm trying with version 2.0.6.
OK.
Ludo'.
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2012-09-04 9:42 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
[not found] <CAHCRas=wo6bkTxzdTqzUe6LjSUZt7ZXX1+TDiPLY_wONo-agNw@mail.gmail.com>
2012-07-08 2:42 ` bug#11878: [guile-2.0.5] install guile-2.0.5 on debian squeeze 32 bit - 2 tests failed Bernardo Ezequiel Contreras
2012-09-03 20:42 ` Ludovic Courtès
2012-09-03 21:51 ` Bernardo Ezequiel Contreras
2012-09-04 9:42 ` Ludovic Courtès
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).