mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-04-30 11:50:28 +02:00
fbb857a472
Conflicts: lib/Makefile.am libguile/Makefile.am libguile/frames.c libguile/gc-card.c libguile/gc-freelist.c libguile/gc-mark.c libguile/gc-segment.c libguile/gc_os_dep.c libguile/load.c libguile/macros.c libguile/objcodes.c libguile/programs.c libguile/strings.c libguile/vm.c m4/gnulib-cache.m4 m4/gnulib-comp.m4 m4/inline.m4
320 lines
9.3 KiB
Scheme
320 lines
9.3 KiB
Scheme
;;;; guardians.test --- test suite for Guile Guardians -*- scheme -*-
|
||
;;;; Jim Blandy <jimb@red-bean.com> --- July 1999
|
||
;;;;
|
||
;;;; Copyright (C) 1999, 2001, 2006 Free Software Foundation, Inc.
|
||
;;;;
|
||
;;;; This library is free software; you can redistribute it and/or
|
||
;;;; modify it under the terms of the GNU Lesser General Public
|
||
;;;; License as published by the Free Software Foundation; either
|
||
;;;; version 3 of the License, or (at your option) any later version.
|
||
;;;;
|
||
;;;; This library is distributed in the hope that it will be useful,
|
||
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
;;;; Lesser General Public License for more details.
|
||
;;;;
|
||
;;;; You should have received a copy of the GNU Lesser General Public
|
||
;;;; License along with this library; if not, write to the Free Software
|
||
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||
|
||
;;; These tests make some questionable assumptions.
|
||
;;;
|
||
;;; - They assume that a GC will find all dead objects, so they
|
||
;;; will become flaky if we have a generational GC.
|
||
;;;
|
||
;;; - More generally, when a weakly referenced object doesn't disappear as
|
||
;;; expected, it's hard to tell whether that's because of a guardian bug of
|
||
;;; because a reference to it is being held somewhere, e.g., one some part
|
||
;;; of the stack that hasn't been overwritten. Thus, most tests cannot
|
||
;;; fail, they can just throw `unresolved'. We try hard to clear
|
||
;;; references that may have been left on the stacks (see "clear refs left
|
||
;;; on the stack" lines).
|
||
;;;
|
||
;;; - They assume that objects won't be saved by the guardian until
|
||
;;; they explicitly invoke GC --- in other words, they assume that GC
|
||
;;; won't happen too often.
|
||
|
||
(define-module (test-guardians)
|
||
:use-module (test-suite lib)
|
||
:use-module (ice-9 documentation)
|
||
:use-module (ice-9 weak-vector))
|
||
|
||
|
||
;;;
|
||
;;; miscellaneous
|
||
;;;
|
||
|
||
(define (documented? object)
|
||
(not (not (object-documentation object))))
|
||
|
||
|
||
(gc)
|
||
|
||
;;; Who guards the guardian?
|
||
|
||
;;; Note: We use strings rather than symbols because symbols are usually
|
||
;;; ``interned'', i.e., kept in a weakly-keyed hash table, thus making them
|
||
;;; inappropriate for the tests below. Furthermore, we use `string-copy' in
|
||
;;; order to make sure that no string is kept around in the interpreter
|
||
;;; unwillingly (e.g., in the source-property weak hash table).
|
||
|
||
(gc)
|
||
(define g2 (make-guardian))
|
||
(g2 (list (string-copy "g2-garbage")))
|
||
(define g3 (make-guardian))
|
||
(g3 (list (string-copy "g3-garbage")))
|
||
(g3 g2)
|
||
(pass-if "g2-garbage not collected yet" (equal? (g2) #f))
|
||
(pass-if "g3-garbage not collected yet" (equal? (g3) #f))
|
||
(set! g2 #f)
|
||
(gc)
|
||
(let ((seen-g3-garbage #f)
|
||
(seen-g2 #f)
|
||
(seen-something-else #f))
|
||
(let loop ()
|
||
(let ((saved (g3)))
|
||
(if saved
|
||
(begin
|
||
(cond
|
||
((equal? saved (list (string-copy "g3-garbage")))
|
||
(set! seen-g3-garbage #t))
|
||
((procedure? saved) (set! seen-g2 saved))
|
||
(else (pk 'junk saved) (set! seen-something-else #t)))
|
||
(loop)))))
|
||
(pass-if "g3-garbage saved" (or seen-g3-garbage (throw 'unresolved)))
|
||
(pass-if "g2-saved" (or (procedure? seen-g2) (throw 'unresolved)))
|
||
(pass-if "nothing else saved" (not seen-something-else))
|
||
|
||
;; FIXME: The following test fails because the guardian for `g2-garbage'
|
||
;; disappared from the weak-car guardian list of `g2-garbage' right before
|
||
;; `g2-garbage' was finalized (in `finalize_guarded ()'). Sample session
|
||
;; (compiled with `-DDEBUG_GUARDIANS'):
|
||
;;
|
||
;; guile> (define g (make-guardian))
|
||
;; guile> (let ((g2 (make-guardian)))
|
||
;; (format #t "g2 = ~x~%" (object-address g2))
|
||
;; (g2 (string-copy "foo"))
|
||
;; (g g2))
|
||
;; g2 = 81fde18
|
||
;; guile> (gc)
|
||
;; finalizing guarded 0x827f6a0 (1 guardians)
|
||
;; guardian for 0x827f6a0 vanished
|
||
;; end of finalize (0x827f6a0)
|
||
;; finalizing guarded 0x81fde18 (1 guardians)
|
||
;; end of finalize (0x81fde18)
|
||
|
||
(pass-if "g2-garbage saved" (or (and (procedure? seen-g2)
|
||
(equal? (seen-g2)
|
||
(list (string-copy
|
||
"g2-garbage"))))
|
||
(throw 'unresolved))))
|
||
|
||
(with-test-prefix "standard guardian functionality"
|
||
|
||
(with-test-prefix "make-guardian"
|
||
|
||
(pass-if "documented?"
|
||
(documented? make-guardian))
|
||
|
||
(pass-if "returns procedure"
|
||
(procedure? (make-guardian)))
|
||
|
||
(pass-if "returns new procedure each time"
|
||
(not (equal? (make-guardian) (make-guardian)))))
|
||
|
||
(with-test-prefix "empty guardian"
|
||
|
||
(pass-if "returns #f"
|
||
(eq? ((make-guardian)) #f))
|
||
|
||
(pass-if "returns always #f"
|
||
(let ((g (make-guardian)))
|
||
(and (eq? (g) #f)
|
||
(begin (gc) (eq? (g) #f))
|
||
(begin (gc) (eq? (g) #f))))))
|
||
|
||
(with-test-prefix "guarding independent objects"
|
||
|
||
(pass-if "guarding immediate"
|
||
(let ((g (make-guardian)))
|
||
(g #f)
|
||
(and (eq? (g) #f)
|
||
(begin (gc) (eq? (g) #f))
|
||
(begin (gc) (eq? (g) #f)))))
|
||
|
||
(pass-if "guarding non-immediate"
|
||
(let ((g (make-guardian)))
|
||
(gc)
|
||
(g (cons #f #f))
|
||
(cons 'clear 'stack) ;; clear refs left on the stack
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(if (not (equal? (g) (cons #f #f)))
|
||
(throw 'unresolved)
|
||
(eq? (g) #f))))))
|
||
|
||
(pass-if "guarding two non-immediates"
|
||
(let ((g (make-guardian)))
|
||
(gc)
|
||
(g (cons #f #f))
|
||
(g (cons #t #t))
|
||
(cons 'clear 'stack) ;; clear refs left on the stack
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(let ((l (list (g) (g))))
|
||
(if (not (or (equal? l (list (cons #f #f) (cons #t #t)))
|
||
(equal? l (list (cons #t #t) (cons #f #f)))))
|
||
(throw 'unresolved)
|
||
(eq? (g) #f)))))))
|
||
|
||
(pass-if "re-guarding non-immediates"
|
||
(let ((g (make-guardian)))
|
||
(gc)
|
||
(g (cons #f #f))
|
||
(cons 'clear 'stack) ;; clear refs left on the stack
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(let ((p (g)))
|
||
(if (not (equal? p (cons #f #f)))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(g p)
|
||
(set! p #f)
|
||
(gc)
|
||
(if (not (equal? (g) (cons #f #f)))
|
||
(throw 'unresolved)
|
||
(eq? (g) #f)))))))))
|
||
|
||
(pass-if "guarding living non-immediate"
|
||
(let ((g (make-guardian))
|
||
(p (cons #f #f)))
|
||
(g p)
|
||
(if (not (eq? (g) #f))
|
||
(throw 'fail)
|
||
(begin
|
||
(gc)
|
||
(not (eq? (g) p)))))))
|
||
|
||
(with-test-prefix "guarding weakly referenced objects"
|
||
|
||
(pass-if "guarded weak vector element gets returned from guardian"
|
||
(let ((g (make-guardian))
|
||
(v (weak-vector #f)))
|
||
(gc)
|
||
(let ((p (cons #f #f)))
|
||
(g p)
|
||
(vector-set! v 0 p)
|
||
(set! p #f)) ;; clear refs left on the stack
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(if (not (equal? (g) (cons #f #f)))
|
||
(throw 'unresolved)
|
||
(eq? (g) #f))))))
|
||
|
||
(pass-if "guarded element of weak vector gets eventually removed from weak vector"
|
||
(let ((g (make-guardian))
|
||
(v (weak-vector #f)))
|
||
(gc)
|
||
(let ((p (cons #f #f)))
|
||
(g p)
|
||
(vector-set! v 0 p)
|
||
(set! p #f)) ;; clear refs left on the stack
|
||
(begin
|
||
(gc)
|
||
(if (not (equal? (g) (cons #f #f)))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(or (not (vector-ref v 0))
|
||
(throw 'unresolved))))))))
|
||
|
||
(with-test-prefix "guarding weak containers"
|
||
|
||
(pass-if "element of guarded weak vector gets collected"
|
||
(let ((g (make-guardian))
|
||
(v (weak-vector #f)))
|
||
;; Note: We don't pass `(cons #f #f)' as an argument to `weak-vector'
|
||
;; otherwise references to it are likely to be left on the stack.
|
||
(vector-set! v 0 (cons #f #f))
|
||
|
||
(g v)
|
||
(gc)
|
||
(if (equal? (vector-ref v 0) (cons #f #f))
|
||
(throw 'unresolved)
|
||
#t))))
|
||
|
||
(with-test-prefix "guarding guardians"
|
||
#t)
|
||
|
||
(with-test-prefix "guarding dependent objects"
|
||
|
||
;; We don't make any guarantees about the order objects are
|
||
;; returned from guardians and therefore we skip the following
|
||
;; test.
|
||
|
||
(if #f
|
||
(pass-if "guarding vector and element"
|
||
(let ((g (make-guardian)))
|
||
(gc)
|
||
(let ((p (cons #f #f)))
|
||
(g p)
|
||
(g (vector p)))
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(if (not (equal? (g) (vector (cons #f #f))))
|
||
(throw 'unresolved)
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(if (not (equal? (g) (cons #f #f)))
|
||
(throw 'unresolved)
|
||
(eq? (g) #f)))))))))))
|
||
|
||
(with-test-prefix "guarding objects more than once"
|
||
|
||
(pass-if "guarding twice in one guardian"
|
||
(let ((g (make-guardian)))
|
||
(gc)
|
||
(let ((p (cons #f #f)))
|
||
(g p)
|
||
(g p)
|
||
(set! p #f)) ;; clear refs left on the stack
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(or (and (and=> (g) (lambda (o) (equal? o (cons #f #f))))
|
||
(and=> (g) (lambda (o) (equal? o (cons #f #f)))))
|
||
(throw 'unresolved))))))
|
||
|
||
(pass-if "guarding twice in two guardians"
|
||
(let ((g (make-guardian))
|
||
(h (make-guardian)))
|
||
(gc)
|
||
(let ((p (cons #f #f)))
|
||
(g p)
|
||
(h p)
|
||
(set! p #f)) ;; clear refs left on the stack
|
||
(if (not (eq? (g) #f))
|
||
(throw 'unresolved)
|
||
(begin
|
||
(gc)
|
||
(or (and (and=> (g) (lambda (o) (equal? o (cons #f #f))))
|
||
(and=> (h) (lambda (o) (equal? o (cons #f #f)))))
|
||
(throw 'unresolved)))))))
|
||
|
||
(with-test-prefix "guarding cyclic dependencies"
|
||
#t)
|
||
|
||
)
|