diff --git a/drracket-test/tests/drracket/private/easter-egg-lib.rkt b/drracket-test/tests/drracket/private/easter-egg-lib.rkt
index f22c39961..979690149 100644
--- a/drracket-test/tests/drracket/private/easter-egg-lib.rkt
+++ b/drracket-test/tests/drracket/private/easter-egg-lib.rkt
@@ -64,7 +64,7 @@ and then loading the framework after that.
        (define drr-frame (wait-for-drracket-frame))
        (set-module-language! drr-frame)
        (queue-callback/res
-        (λ () (send (send (send drr-frame get-definitions-text) get-canvas) focus)))
+        (λ () (send+ drr-frame (get-definitions-text) (get-canvas) (focus))))
        (for ([x (in-string "(car 'x)")])
          (test:keystroke x))
        (let ([button (queue-callback/res (λ () (send drr-frame get-execute-button)))])
@@ -81,15 +81,12 @@ and then loading the framework after that.
      (define (wait-for-drracket-frame [print-message? #f])
        (define (wait-for-drracket-frame-pred)
          (define active (test:get-active-top-level-window))
-         (if (and active
-                  (drracket-frame? active))
-             active
-             #f))
+         (and active (drracket-frame? active) active))
        (define drr-fr
          (or (wait-for-drracket-frame-pred)
              (begin
                (when print-message?
-                 (printf "Select DrRacket frame\n"))
+                 (displayln "Select DrRacket frame"))
                (poll-until wait-for-drracket-frame-pred))))
        (when drr-fr
          (wait-for-events-in-frame-eventspace drr-fr))
@@ -113,10 +110,9 @@ and then loading the framework after that.
 
      (define (verify-drracket-frame-frontmost function-name frame)
        (on-eventspace-handler-thread 'verify-drracket-frame-frontmost)
-       (let ([tl (test:get-active-top-level-window)])
-         (unless (and (eq? frame tl)
-                      (drracket-frame? tl))
-           (error function-name "drracket frame not frontmost: ~e (found ~e)" frame tl))))
+       (define tl (test:get-active-top-level-window))
+       (unless (and (eq? frame tl) (drracket-frame? tl))
+         (error function-name "drracket frame not frontmost: ~e (found ~e)" frame tl)))
      
      (define (set-module-language! drr-frame)
        (test:menu-select "Language" "Choose Language…")
diff --git a/drracket-test/tests/drracket/private/gui.rkt b/drracket-test/tests/drracket/private/gui.rkt
index b4709ac1b..74cc3bad8 100644
--- a/drracket-test/tests/drracket/private/gui.rkt
+++ b/drracket-test/tests/drracket/private/gui.rkt
@@ -17,30 +17,17 @@
       (cond
         [(= i (string-length string1)) (only-whitespace? string2 j)]
         [(= j (string-length string2)) (only-whitespace? string1 i)]
-        [else (let ([c1 (string-ref string1 i)]
-                    [c2 (string-ref string2 j)])
-                (cond
-                  [in-whitespace?
-                   (cond
-                     [(whitespace? c1)
-                      (loop (+ i 1)
-                            j
-                            #t)]
-                     [(whitespace? c2)
-                      (loop i
-                            (+ j 1)
-                            #t)]
-                     [else (loop i j #f)])]
-                  [(and (whitespace? c1)
-                        (whitespace? c2))
-                   (loop (+ i 1)
-                         (+ j 1)
-                         #t)]
-                  [(char=? c1 c2)
-                   (loop (+ i 1)
-                         (+ j 1)
-                         #f)]
-                  [else #f]))])))
+        [else (define c1 (string-ref string1 i))
+              (define c2 (string-ref string2 j))
+              (cond
+                [in-whitespace?
+                 (cond
+                   [(whitespace? c1) (loop (+ i 1) j #t)]
+                   [(whitespace? c2) (loop i (+ j 1) #t)]
+                   [else (loop i j #f)])]
+                [(and (whitespace? c1) (whitespace? c2)) (loop (+ i 1) (+ j 1) #t)]
+                [(char=? c1 c2) (loop (+ i 1) (+ j 1) #f)]
+                [else #f])])))
   
   ;; whitespace? : char -> boolean
   ;; deteremines if `c' is whitespace
@@ -113,11 +100,11 @@
              window label class))
     (let loop ([window window])
       (cond
-        [(and (or (not class)
-                  (is-a? window class))
-              (let ([win-label (and (is-a? window window<%>)
-                                    (send window get-label))])
-                (equal? label win-label)))
+        [(cond
+           [(or (not class) (is-a? window class))
+            (define win-label (and (is-a? window window<%>) (send window get-label)))
+            (equal? label win-label)]
+           [else #f])
          (list window)]
         [(is-a? window area-container<%>) (apply append (map loop (send window get-children)))]
         [else '()])))
diff --git a/drracket-test/tests/drracket/private/no-fw-test-util.rkt b/drracket-test/tests/drracket/private/no-fw-test-util.rkt
index a47a10584..5a1beaaee 100644
--- a/drracket-test/tests/drracket/private/no-fw-test-util.rkt
+++ b/drracket-test/tests/drracket/private/no-fw-test-util.rkt
@@ -105,32 +105,35 @@
   (not-on-eventspace-handler-thread
    'queue-callback/res
    #:more (λ () (format "\n  thunk: ~e" thunk)))
-  (let ([c (make-channel)])
-    (queue-callback (λ () (channel-put c (with-handlers ((exn:fail? values))
-                                           (call-with-values thunk list))))
-                    #f)
-    (define res (channel-get c))
-    (when (exn? res) (raise res))
-    (apply values res)))
+  (define c (make-channel))
+  (queue-callback (λ ()
+                    (channel-put c
+                                 (with-handlers ([exn:fail? values])
+                                   (call-with-values thunk list))))
+                  #f)
+  (define res (channel-get c))
+  (when (exn? res)
+    (raise res))
+  (apply values res))
 
 ;; poll-until : (-> alpha) number (-> alpha) -> alpha
 ;; waits until pred return a true value and returns that.
 ;; if that doesn't happen by `secs', calls fail and returns that.
-(define (poll-until pred
-                    [secs 10]
-                    [fail (lambda ()
-                            (error 'poll-until 
-                                   "timeout after ~e secs, ~e never returned a true value"
-                                   secs pred))])
-  (let ([step 1/20])
-    (let loop ([counter secs])
-      (if (<= counter 0)
-          (fail)
-          (let ([result (pred)])
-            (or result
-                (begin
-                  (sleep step)
-                  (loop (- counter step)))))))))
+(define (poll-until
+         pred
+         [secs 10]
+         [fail
+          (lambda ()
+            (error 'poll-until "timeout after ~e secs, ~e never returned a true value" secs pred))])
+  (define step 1/20)
+  (let loop ([counter secs])
+    (if (<= counter 0)
+        (fail)
+        (let ([result (pred)])
+          (or result
+              (begin
+                (sleep step)
+                (loop (- counter step))))))))
 
 (define (wait-for-events-in-frame-eventspace fr)
   (define sema (make-semaphore 0))
diff --git a/drracket-test/tests/drracket/private/repl-test.rkt b/drracket-test/tests/drracket/private/repl-test.rkt
index 0eea73aa8..c44baec9d 100644
--- a/drracket-test/tests/drracket/private/repl-test.rkt
+++ b/drracket-test/tests/drracket/private/repl-test.rkt
@@ -18,7 +18,7 @@ This produces an ACK message
          mred
          framework)
 
-(provide/contract [run-test (-> (listof (or/c 'raw 'debug 'debug/profile 'misc)) any)])
+(provide (contract-out [run-test (-> (listof (or/c 'raw 'debug 'debug/profile 'misc)) any)]))
 
 (define-struct loc (line col offset))
 ;; loc = (make-loc number number number)
@@ -1010,7 +1010,7 @@ This produces an ACK message
 (define backtrace-image-string "{stop-multi.png}")
 (define file-image-string "{stop-22x22.png}")
 
-(define tmp-load-directory (make-temporary-file "repltest~a" 'directory))
+(define tmp-load-directory (make-temporary-directory "repltest~a"))
 
 (define tmp-load-short-filename "repl-test-tmp.rkt")
 (define tmp-load-filename (build-path tmp-load-directory tmp-load-short-filename))
@@ -1047,15 +1047,15 @@ This produces an ACK message
     (define snip
       (queue-callback/res
        (lambda ()
-         (let* ([start (send ints-text paragraph-start-position 2)]
-                ;; since the fraction is supposed to be one char wide, we just
-                ;; select one char, so that, if the regular number prints out,
-                ;; this test will fail.
-                [end (+ start 1)])
-           (send ints-text split-snip start)
-           (send ints-text split-snip end)
-           (define snip (send ints-text find-snip start 'after))
-           (and snip (send snip copy))))))
+         (define start (send ints-text paragraph-start-position 2))
+         ;; since the fraction is supposed to be one char wide, we just
+         ;; select one char, so that, if the regular number prints out,
+         ;; this test will fail.
+         (define end (+ start 1))
+         (send ints-text split-snip start)
+         (send ints-text split-snip end)
+         (define snip (send ints-text find-snip start 'after))
+         (and snip (send snip copy)))))
     (clear-definitions drr-frame)
     (type-in-definitions drr-frame "(+ ")
     (queue-callback/res
@@ -1069,175 +1069,157 @@ This produces an ACK message
   ; results of these operations against expected results.
   (define ((run-single-test execute-text-start escape language-cust) in-vector)
     ;(printf "\n>> testing ~s\n" (test-program in-vector))
-    (let* ([program (test-program in-vector)]
-           [execute-answer (make-execute-answer in-vector language-cust)]
-           [source-location (test-source-location in-vector)]
-           [setup (test-setup in-vector)]
-           [teardown (test-teardown in-vector)]
-           [breaking-test? (test-breaking-test? in-vector)])
-      
-      (setup)
-      
-      (clear-definitions drr-frame)
-      ; load contents of test-file into the REPL, recording
-      ; the start and end positions of the text
-      
-      (wait-for-drracket-frame)
-      
-      (cond
-        [(string? program)
-         (insert-in-definitions/newlines drr-frame program)]
-        [(eq? program 'fraction-sum)
-         (setup-fraction-sum-interactions)]
-        [(list? program)
-         (for-each
-          (lambda (item)
-            (cond
-              [(string? item) (insert-in-definitions/newlines drr-frame item)]
-              [(eq? item 'left)
-               (queue-callback/res
-                (λ ()
-                  (send defs-text 
-                        set-position
-                        (- (send defs-text get-start-position) 1)
-                        (- (send defs-text get-start-position) 1))))]
-              [(pair? item) (apply test:menu-select item)]))
-          program)])
-      
+    (define program (test-program in-vector))
+    (define execute-answer (make-execute-answer in-vector language-cust))
+    (define source-location (test-source-location in-vector))
+    (define setup (test-setup in-vector))
+    (define teardown (test-teardown in-vector))
+    (define breaking-test? (test-breaking-test? in-vector))
+  
+    (setup)
+  
+    (clear-definitions drr-frame)
+    ; load contents of test-file into the REPL, recording
+    ; the start and end positions of the text
+  
+    (wait-for-drracket-frame)
+  
+    (cond
+      [(string? program) (insert-in-definitions/newlines drr-frame program)]
+      [(eq? program 'fraction-sum) (setup-fraction-sum-interactions)]
+      [(list? program)
+       (for ([item (in-list program)])
+         (cond
+           [(string? item) (insert-in-definitions/newlines drr-frame item)]
+           [(eq? item 'left)
+            (queue-callback/res (λ ()
+                                  (send defs-text set-position
+                                        (- (send defs-text get-start-position) 1)
+                                        (- (send defs-text get-start-position) 1))))]
+           [(pair? item) (apply test:menu-select item)]))]
+      [else (void)])
+  
+    (do-execute drr-frame #f)
+  
+    ;; make sure that the execute callback has really completed
+    ;; (is this necc w/ test:run-one below?)
+    (queue-callback/res void)
+  
+    (when breaking-test?
+      (test:run-one (λ () (send (send drr-frame get-break-button) command))))
+    (wait-for-drr-frame-computation)
+  
+    (define execute-text-end (max 0 (- (get-int-pos) 1))) ;; subtract one to skip last newline
+    (define received-execute (fetch-output drr-frame execute-text-start execute-text-end))
+  
+    ; check focus and selection for execute test
+    (case language-cust
+      [(raw) (void)]
+      [else
+       (define edit-target (queue-callback/res (λ () (send drr-frame get-edit-target-window))))
+       (define defs-focus? (eq? edit-target defs-canvas))
+       (define ints-focus? (eq? edit-target ints-canvas))
+       (cond
+         [(eq? source-location 'dont-care) (void)]
+         [(eq? source-location 'definitions)
+          (unless defs-focus?
+            (eprintf "FAILED execute test for ~s\n  expected definitions to have the focus\n"
+                     program))]
+         [(eq? source-location 'interactions)
+          (unless ints-focus?
+            (eprintf "FAILED execute test for ~s\n  expected interactions to have the focus\n"
+                     program))]
+         [defs-focus?
+          (define start (car source-location))
+          (define finish (cdr source-location))
+          (define error-ranges (queue-callback/res (λ () (send ints-text get-error-ranges))))
+          (define error-range (and error-ranges (not (null? error-ranges)) (car error-ranges)))
+          (unless (and error-range
+                       (= (+ (srcloc-position error-range) -1) (loc-offset start))
+                       (= (+ (srcloc-position error-range) -1 (srcloc-span error-range))
+                          (loc-offset finish)))
+            (eprintf "FAILED execute test for ~s\n  error-range is ~s\n  expected ~s\n"
+                     program
+                     (and error-range
+                          (list (+ (srcloc-position error-range) -1)
+                                (+ (srcloc-position error-range) -1 (srcloc-span error-range))))
+                     (list (loc-offset start) (loc-offset finish))))])])
+  
+    ; check text for execute test
+    (next-test)
+    (unless (cond
+              [(string? execute-answer) (string=? execute-answer received-execute)]
+              [(regexp? execute-answer) (regexp-match execute-answer received-execute)]
+              [else #f])
+      (failure)
+      (eprintf "FAILED execute test for ~s (~a)\n  expected: ~s\n       got: ~s\n"
+               program
+               language-cust
+               execute-answer
+               received-execute))
+  
+    (test:new-window ints-canvas)
+  
+    ; save the file so that load is in sync
+    (test:menu-select "File" "Save Definitions")
+  
+    ; make sure that a prompt is available at end of the REPL
+    (unless (queue-callback/res
+             (λ ()
+               (and (char=? #\> (send ints-text get-character (- (send ints-text last-position) 2)))
+                    (char=? #\space
+                            (send ints-text get-character (- (send ints-text last-position) 1))))))
+      (test:keystroke #\return))
+  
+    (define (load-test short-filename load-answer)
+      ;; in order to erase the state in the namespace already, we clear (but don't save!)
+      ;; the definitions and click execute with the empty buffer
+      (test:new-window defs-canvas)
+      (test:menu-select "Edit" "Select All")
+      (test:menu-select "Edit" "Delete")
       (do-execute drr-frame #f)
-      
-      ;; make sure that the execute callback has really completed 
-      ;; (is this necc w/ test:run-one below?)
-      (queue-callback/res void)
-      
+      (wait-for-drr-frame-computation)
+  
+      ;; stuff the load command into the REPL
+      (insert-in-interactions drr-frame (format "(load ~s)" short-filename))
+  
+      ;; record current text position, then stuff a CR into the REPL
+      (define load-text-start (+ 1 (queue-callback/res (λ () (send ints-text last-position)))))
+  
+      (test:keystroke #\return)
+  
       (when breaking-test?
         (test:run-one (λ () (send (send drr-frame get-break-button) command))))
       (wait-for-drr-frame-computation)
+  
+      (define load-text-end (- (get-int-pos) 1)) ;; subtract one to eliminate newline
+      (define received-load (fetch-output drr-frame load-text-start load-text-end))
       
-      (let* ([execute-text-end (max 0 (- (get-int-pos) 1))] ;; subtract one to skip last newline
-             [received-execute
-              (fetch-output drr-frame execute-text-start execute-text-end)])
-        
-        ; check focus and selection for execute test
-        (case language-cust
-          [(raw) (void)]
-          [else
-           (define edit-target 
-             (queue-callback/res (λ () (send drr-frame get-edit-target-window))))
-           (define defs-focus? (eq? edit-target defs-canvas))
-           (define ints-focus? (eq? edit-target ints-canvas))
-           (cond
-             [(eq? source-location 'dont-care)
-              (void)]
-             [(eq? source-location 'definitions)
-              (unless defs-focus?
-                (eprintf "FAILED execute test for ~s\n  expected definitions to have the focus\n"
-                         program))]
-             [(eq? source-location 'interactions)
-              (unless ints-focus?
-                (eprintf "FAILED execute test for ~s\n  expected interactions to have the focus\n"
-                         program))]
-             [defs-focus?
-               (let ([start (car source-location)]
-                     [finish (cdr source-location)])
-                 (let* ([error-ranges (queue-callback/res (λ () (send ints-text get-error-ranges)))]
-                        [error-range (and error-ranges
-                                          (not (null? error-ranges))
-                                          (car error-ranges))])
-                   (unless (and error-range
-                                (= (+ (srcloc-position error-range) -1) (loc-offset start))
-                                (= (+ (srcloc-position error-range) -1 (srcloc-span error-range)) 
-                                   (loc-offset finish)))
-                     (eprintf "FAILED execute test for ~s\n  error-range is ~s\n  expected ~s\n"
-                              program
-                              (and error-range
-                                   (list (+ (srcloc-position error-range) -1)
-                                         (+ (srcloc-position error-range) -1 
-                                            (srcloc-span error-range))))
-                              (list (loc-offset start)
-                                    (loc-offset finish))))))])])
-        
-        ; check text for execute test
-        (next-test)
-        (unless (cond
-                  [(string? execute-answer)
-                   (string=? execute-answer received-execute)]
-                  [(regexp? execute-answer)
-                   (regexp-match execute-answer received-execute)]
-                  [else #f])
-          (failure)
-          (eprintf "FAILED execute test for ~s (~a)\n  expected: ~s\n       got: ~s\n"
-                   program
-                   language-cust
-                   execute-answer received-execute))
-        
-        (test:new-window ints-canvas)
-        
-        ; save the file so that load is in sync
-        (test:menu-select "File" "Save Definitions")
-        
-        ; make sure that a prompt is available at end of the REPL
-        (unless (queue-callback/res
-                 (λ () 
-                   (and (char=? #\>
-                                (send ints-text get-character
-                                      (- (send ints-text last-position) 2)))
-                        (char=? #\space
-                                (send ints-text get-character
-                                      (- (send ints-text last-position) 1))))))
-          (test:keystroke #\return))
-        
-        (define (load-test short-filename load-answer)
-          ;; in order to erase the state in the namespace already, we clear (but don't save!)
-          ;; the definitions and click execute with the empty buffer
-          (test:new-window defs-canvas)
-          (test:menu-select "Edit" "Select All")
-          (test:menu-select "Edit" "Delete")
-          (do-execute drr-frame #f)
-          (wait-for-drr-frame-computation)
-          
-          ;; stuff the load command into the REPL 
-          (insert-in-interactions drr-frame (format "(load ~s)" short-filename))
-          
-          ;; record current text position, then stuff a CR into the REPL
-          (define load-text-start 
-            (+ 1 (queue-callback/res (λ () (send ints-text last-position)))))
-          
-          (test:keystroke #\return)
-          
-          (when breaking-test?
-            (test:run-one (λ () (send (send drr-frame get-break-button) command))))
-          (wait-for-drr-frame-computation)
-          
-          (let* ([load-text-end (- (get-int-pos) 1)] ;; subtract one to eliminate newline
-                 [received-load 
-                  (fetch-output drr-frame load-text-start load-text-end)])
-            
-            ;; check load text 
-            (next-test)
-            (unless (cond
-                      [(string? load-answer)
-                       (string=? load-answer received-load)]
-                      [(regexp? load-answer)
-                       (regexp-match load-answer received-load)]
-                      [else #f])
-              (failure)
-              (eprintf "FAILED load test ~a for ~s\n  expected: ~s\n       got: ~s\n"
-                       short-filename
-                       program load-answer received-load))))
-        (load-test tmp-load-short-filename (make-load-answer in-vector language-cust #f))
-        (when (file-exists? tmp-load3-filename)
-          (delete-file tmp-load3-filename))
-        (copy-file tmp-load-filename tmp-load3-filename)
-        (load-test tmp-load3-short-filename 
-                   (make-load-answer in-vector language-cust tmp-load3-short-filename))
-        
-        (teardown)
-        
-        ; check for edit-sequence
-        (when (repl-in-edit-sequence?)
-          (eprintf "FAILED: repl in edit-sequence")
-          (escape)))))
+      ;; check load text
+      (next-test)
+      (unless (cond
+                [(string? load-answer) (string=? load-answer received-load)]
+                [(regexp? load-answer) (regexp-match load-answer received-load)]
+                [else #f])
+        (failure)
+        (eprintf "FAILED load test ~a for ~s\n  expected: ~s\n       got: ~s\n"
+                 short-filename
+                 program
+                 load-answer
+                 received-load)))
+    (load-test tmp-load-short-filename (make-load-answer in-vector language-cust #f))
+    (when (file-exists? tmp-load3-filename)
+      (delete-file tmp-load3-filename))
+    (copy-file tmp-load-filename tmp-load3-filename)
+    (load-test tmp-load3-short-filename
+               (make-load-answer in-vector language-cust tmp-load3-short-filename))
+  
+    (teardown)
+  
+    ; check for edit-sequence
+    (when (repl-in-edit-sequence?)
+      (eprintf "FAILED: repl in edit-sequence")
+      (escape)))
   
   (define tests 0)
   (define failures 0)
@@ -1312,16 +1294,16 @@ This produces an ACK message
     (wait-for-drr-frame-computation)
     
     (for-each test:keystroke (string->list "x"))
-    (let ([start (+ 1 (queue-callback/res (λ () (send ints-text last-position))))])
-      (test:keystroke #\return)
-      (wait-for-drr-frame-computation)
-      
-      (let* ([end (- (get-int-pos) 1)]
-             [output (fetch-output drr-frame start end)]
-             [expected #rx"x:.*cannot reference an identifier before its definition"])
-        (unless (regexp-match expected output)
-          (failure)
-          (eprintf "callcc-test: expected something matching ~s, got ~s\n" expected output)))))
+    (define start (+ 1 (queue-callback/res (λ () (send ints-text last-position)))))
+    (test:keystroke #\return)
+    (wait-for-drr-frame-computation)
+    
+    (define end (- (get-int-pos) 1))
+    (define output (fetch-output drr-frame start end))
+    (define expected #rx"x:.*cannot reference an identifier before its definition")
+    (unless (regexp-match expected output)
+      (failure)
+      (eprintf "callcc-test: expected something matching ~s, got ~s\n" expected output)))
   
   (define (random-seed-test)
     (define expression 
@@ -1332,57 +1314,55 @@ This produces an ACK message
     (wait-for-drr-frame-computation)
     
     (insert-in-interactions drr-frame expression)
-    (let ([start1 (+ 1 (queue-callback/res (λ () (send ints-text last-position))))])
-      (test:keystroke #\return)
-      (wait-for-drr-frame-computation)
-      (let ([output1 (fetch-output drr-frame start1 (- (get-int-pos) 1))])
-        (insert-in-interactions drr-frame expression)
-        (let ([start2 (+ 1 (queue-callback/res (λ () (send ints-text last-position))))])
-          (test:keystroke #\return)
-          (wait-for-drr-frame-computation)
-          (let ([output2 (fetch-output drr-frame start2 (- (get-int-pos) 1))])
-            (unless (equal? output1 output2)
-              (failure)
-              (eprintf "random-seed-test: expected\n  ~s\nand\n  ~s\nto be the same"
-                       output1
-                       output2)))))))
+    (define start1 (+ 1 (queue-callback/res (λ () (send ints-text last-position)))))
+    (test:keystroke #\return)
+    (wait-for-drr-frame-computation)
+    (define output1 (fetch-output drr-frame start1 (- (get-int-pos) 1)))
+    (insert-in-interactions drr-frame expression)
+    (define start2 (+ 1 (queue-callback/res (λ () (send ints-text last-position)))))
+    (test:keystroke #\return)
+    (wait-for-drr-frame-computation)
+    (define output2 (fetch-output drr-frame start2 (- (get-int-pos) 1)))
+    (unless (equal? output1 output2)
+      (failure)
+      (eprintf "random-seed-test: expected\n  ~s\nand\n  ~s\nto be the same" output1 output2)))
   
   (define (top-interaction-test)
     (clear-definitions drr-frame)
     (do-execute drr-frame)
     (wait-for-drr-frame-computation)
-    (let ([ints-just-after-welcome (queue-callback/res (λ () (+ 1 (send ints-text last-position))))])
-      
-      (type-in-definitions 
-       drr-frame
-       "(define-syntax #%top-interaction (syntax-rules () [(_ . e) 'e]))\n(+ 1 2)\n")
-      (test:menu-select "File" "Save Definitions")
-      
-      (clear-definitions drr-frame)
-      (do-execute drr-frame)
+    (define ints-just-after-welcome (queue-callback/res (λ () (+ 1 (send ints-text last-position)))))
+    
+    (type-in-definitions
+     drr-frame
+     "(define-syntax #%top-interaction (syntax-rules () [(_ . e) 'e]))\n(+ 1 2)\n")
+    (test:menu-select "File" "Save Definitions")
+    
+    (clear-definitions drr-frame)
+    (do-execute drr-frame)
+    (wait-for-drr-frame-computation)
+    
+    (for-each test:keystroke (string->list (format "(load ~s)" tmp-load-short-filename)))
+    (let ([start (+ 1 (queue-callback/res (λ () (send ints-text last-position))))])
+      (test:keystroke #\return)
       (wait-for-drr-frame-computation)
-      
-      (for-each test:keystroke (string->list (format "(load ~s)" tmp-load-short-filename)))
-      (let ([start (+ 1 (queue-callback/res (λ () (send ints-text last-position))))])
-        (test:keystroke #\return)
-        (wait-for-drr-frame-computation)
-        (let* ([end (- (get-int-pos) 1)]
-               [output (fetch-output drr-frame start end)]
-               [expected "(+ 1 2)"])
-          (unless (equal? output expected)
-            (error 'top-interaction-test "expected.1 ~s, got ~s" expected output))
-          (next-test)))
-      
-      (for-each test:keystroke (string->list "(+ 4 5)"))
-      (let ([start (+ 1 (queue-callback/res (λ () (send ints-text last-position))))])
-        (test:keystroke #\return)
-        (wait-for-drr-frame-computation)
-        (let* ([end (- (get-int-pos) 1)]
-               [output (fetch-output drr-frame start end)]
-               [expected "(+ 4 5)"])
-          (unless (equal? output expected)
-            (error 'top-interaction-test "expected.2 ~s, got ~s" expected output))
-          (next-test)))))
+      (let* ([end (- (get-int-pos) 1)]
+             [output (fetch-output drr-frame start end)]
+             [expected "(+ 1 2)"])
+        (unless (equal? output expected)
+          (error 'top-interaction-test "expected.1 ~s, got ~s" expected output))
+        (next-test)))
+    
+    (for-each test:keystroke (string->list "(+ 4 5)"))
+    (define start (+ 1 (queue-callback/res (λ () (send ints-text last-position)))))
+    (test:keystroke #\return)
+    (wait-for-drr-frame-computation)
+    (define end (- (get-int-pos) 1))
+    (define output (fetch-output drr-frame start end))
+    (define expected "(+ 4 5)")
+    (unless (equal? output expected)
+      (error 'top-interaction-test "expected.2 ~s, got ~s" expected output))
+    (next-test))
   
   (when (file-exists? tmp-load-filename)
     (delete-file tmp-load-filename))