suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tests for splay-tree and skip-list

Browse Source
This commit is contained in:
Ryan Culpepper 2010-09-12 22:19:00 -06:00
parent e72244513d
commit 999c33827c
2 changed files with 72 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
collects/data/splay-tree.rkt
View File

@ -444,7 +444,7 @@ Options
(define-syntax-rule (mkcmp <? =?)
(lambda (x y) (cond [(=? x y) '=] [(<? x y) '<] [else '>])))
(define (make-splay-tree <? =?
(define (make-splay-tree =? <?
#:key-contract [key-contract any/c]
#:value-contract [value-contract any/c])
(cond [(and (eq? key-contract any/c) (eq? value-contract any/c))
@ -488,7 +488,7 @@ In an integer splay tree, keys can be stored relative to their parent nodes.
[else
(values #f root)])])
(set-splay-tree-root! s root)
(and ok? (splay-tree-iter root)))]))
(and ok? (splay-tree-iter (node-key root))))]))
(define (splay-tree-iterate-greatest/<=? s key)
(extreme 'splay-tree-iterate-greatest/<=? s key '(< =) has-prev? find-prev))

70
collects/tests/data/ordered-dict.rkt Normal file
View File

@ -0,0 +1,70 @@
#lang racket/base
(require rackunit
racket/dict
data/skip-list
data/splay-tree)
;; Tests for ordered dictionaries
;; - skip-list
;; - splay-tree
(define (it-least/>? d k)
(cond [(skip-list? d) (skip-list-iterate-least/>? d k)]
[(splay-tree? d) (splay-tree-iterate-least/>? d k)]))
(define (it-least/>=? d k)
(cond [(skip-list? d) (skip-list-iterate-least/>=? d k)]
[(splay-tree? d) (splay-tree-iterate-least/>=? d k)]))
(define (it-greatest/<? d k)
(cond [(skip-list? d) (skip-list-iterate-greatest/<? d k)]
[(splay-tree? d) (splay-tree-iterate-greatest/<? d k)]))
(define (it-greatest/<=? d k)
(cond [(skip-list? d) (skip-list-iterate-greatest/<=? d k)]
[(splay-tree? d) (splay-tree-iterate-greatest/<=? d k)]))
(test-case "random keys and values"
(let ([hash (make-hash)]
[dicts (list (make-skip-list = <)
(make-splay-tree = <)
(make-integer-splay-tree #:adjust? #t))])
(for ([c (in-range 100)])
(let* ([k (- (random 2000) 1000)]
[v (- (random 2000) 1000)])
(for ([d (cons hash dicts)])
(dict-set! d k v))))
(for ([i (in-range -1000 1000)])
(for ([d dicts])
(let ([vh (hash-ref hash i 'not-there)]
[vd (dict-ref d i 'not-there)])
(check-equal? vh vd (format "dict ~e, key = ~s, value = ~s, expected = ~s"
d i vd vh)))))
(for ([c (in-range 100)])
(let* ([k0 (- (random 2000) 1000)])
(for ([d dicts])
(let* ([has? (dict-has-key? d k0)]
[l>i (it-least/>? d k0)]
[l>=i (it-least/>=? d k0)]
[g<i (it-greatest/<? d k0)]
[g<=i (it-greatest/<=? d k0)]
[l> (and l>i (dict-iterate-key d l>i))]
[l>= (and l>=i (dict-iterate-key d l>=i))]
[g< (and g<i (dict-iterate-key d g<i))]
[g<= (and g<=i (dict-iterate-key d g<=i))])
(when has?
(check-equal? l>= g<= "has, should be same"))
(unless has?
(check-equal? l> l>= "not has, should be same")
(check-equal? g< g<= "not has, should be same"))
(when l> (check > l> k0))
(when l>= (check >= l>= k0))
(when g< (check < g< k0))
(when g<= (check <= g<= k0))
(for ([k (in-dict-keys d)])
(when (and l> (and (> k k0) (< k l>))) (error "l>"))
(when (and l>= (and (>= k k0) (< k l>=))) (error "l>="))
(when (and g< (and (< k k0) (> k g<))) (error "g<"))
(when (and g<= (and (<= k k0) (> k g<=))) (error "g<=")))))))))