diff --git a/collects/data/splay-tree.rkt b/collects/data/splay-tree.rkt
index 8f4a2995e7..967bd0ce2e 100644
--- a/collects/data/splay-tree.rkt
+++ b/collects/data/splay-tree.rkt
@@ -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))
diff --git a/collects/tests/data/ordered-dict.rkt b/collects/tests/data/ordered-dict.rkt
new file mode 100644
index 0000000000..55d026f931
--- /dev/null
+++ b/collects/tests/data/ordered-dict.rkt
@@ -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<=")))))))))