Refactor(English): Rename all files and identifiers from Dutch to English

Renamed files: constanten→constants, adt-positie→adt-position,
adt-doolhof→adt-maze, adt-sleutel→adt-key, adt-tijdslimiet→adt-timer,
adt-teken→adt-draw, adt-spel→adt-game. All message names, variables,
comments, and tests converted to English.

Also fixed counter location bug (time-label x/y were swapped).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

pacman-project/tests/all-tests.rkt

@@ -0,0 +1,24 @@
+#lang r7rs
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                              All Tests                                    ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Runs all ADT tests. Open this file and evaluate to run everything.
+
+(import (scheme base)
+        (pp1 tests)
+        (prefix (pacman-project tests test-position) position:)
+        (prefix (pacman-project tests test-maze) maze:)
+        (prefix (pacman-project tests test-pacman) pacman:)
+        (prefix (pacman-project tests test-score) score:)
+        (prefix (pacman-project tests test-timer) timer:))
+
+(define (test-all)
+  (position:test)
+  (maze:test)
+  (pacman:test)
+  (score:test)
+  (timer:test))
+
+(test-all)

pacman-project/tests/alle-testen.rkt

@@ -1,25 +0,0 @@
-#lang r7rs
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                            Alle Testen                                    ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Voert alle ADT-testen uit. Open dit bestand en evalueer om alle testen
-;; tegelijkertijd te draaien.
-
-(import (scheme base)
-        (pp1 tests)
-        (prefix (pacman-project tests test-positie) positie:)
-        (prefix (pacman-project tests test-doolhof) doolhof:)
-        (prefix (pacman-project tests test-pacman) pacman:)
-        (prefix (pacman-project tests test-score) score:)
-        (prefix (pacman-project tests test-tijdslimiet) tijdslimiet:))
-
-(define (test-alles)
-  (positie:test)
-  (doolhof:test)
-  (pacman:test)
-  (score:test)
-  (tijdslimiet:test))
-
-(test-alles)

pacman-project/tests/test-doolhof.rkt

@@ -1,59 +0,0 @@
-#lang r7rs
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                           Tests: Doolhof ADT                              ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(define-library (pacman-project tests test-doolhof)
-  (import (scheme base)
-          (pp1 tests)
-          (pacman-project constanten)
-          (pacman-project adt-doolhof))
-  (export test)
-
-  (begin
-
-    ;; Test dimensies
-    (define (test-dimensies)
-      (define d (maak-doolhof))
-      (check-eq? (d 'rijen) 31 "Doolhof moet 31 rijen hebben")
-      (check-eq? (d 'kolommen) 28 "Doolhof moet 28 kolommen hebben"))
-
-    ;; Test muur detectie (rij 0 is volledig muur)
-    (define (test-muur)
-      (define d (maak-doolhof))
-      (check ((d 'muur?) 0 0) "Cel (0,0) moet een muur zijn")
-      (check ((d 'muur?) 0 14) "Cel (0,14) moet een muur zijn"))
-
-    ;; Test muntje detectie
-    (define (test-muntje)
-      (define d (maak-doolhof))
-      (check ((d 'muntje?) 1 1) "Cel (1,1) moet een muntje zijn")
-      (check (not ((d 'muntje?) 0 0)) "Cel (0,0) mag geen muntje zijn"))
-
-    ;; Test deur detectie
-    (define (test-deur)
-      (define d (maak-doolhof))
-      (check ((d 'deur?) 4 3) "Cel (4,3) moet een deur zijn")
-      (check (not ((d 'deur?) 1 1)) "Cel (1,1) mag geen deur zijn"))
-
-    ;; Test cel-set! en verwijder-deur!
-    (define (test-mutatie)
-      (define d (maak-doolhof))
-      ((d 'verwijder-deur!) 4 3)
-      (check ((d 'leeg?) 4 3) "Cel (4,3) moet leeg zijn na verwijder-deur!")
-      (check (not ((d 'deur?) 4 3)) "Cel (4,3) mag geen deur meer zijn"))
-
-    ;; Test dat Pac-Man niet door muur kan (muur blokkeert)
-    (define (test-muur-blokkade)
-      (define d (maak-doolhof))
-      ;; Pac-Man staat op (1,1) en wil naar links (1,0) -> dat is een muur
-      (check ((d 'muur?) 1 0) "Cel (1,0) is een muur, Pac-Man kan niet door"))
-
-    (define (test)
-      (run-test test-dimensies "Doolhof: dimensies")
-      (run-test test-muur "Doolhof: muur detectie")
-      (run-test test-muntje "Doolhof: muntje detectie")
-      (run-test test-deur "Doolhof: deur detectie")
-      (run-test test-mutatie "Doolhof: cel mutatie")
-      (run-test test-muur-blokkade "Doolhof: muur blokkeert beweging"))))

pacman-project/tests/test-maze.rkt

@@ -0,0 +1,58 @@
+#lang r7rs
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                            Tests: Maze ADT                                ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-library (pacman-project tests test-maze)
+  (import (scheme base)
+          (pp1 tests)
+          (pacman-project constants)
+          (pacman-project adt-maze))
+  (export test)
+
+  (begin
+
+    ;; Test dimensions
+    (define (test-dimensions)
+      (define m (make-maze))
+      (check-eq? (m 'rows) 31 "Maze should have 31 rows")
+      (check-eq? (m 'cols) 28 "Maze should have 28 cols"))
+
+    ;; Test wall detection (row 0 is all walls)
+    (define (test-wall)
+      (define m (make-maze))
+      (check ((m 'wall?) 0 0) "Cell (0,0) should be a wall")
+      (check ((m 'wall?) 0 14) "Cell (0,14) should be a wall"))
+
+    ;; Test coin detection
+    (define (test-coin)
+      (define m (make-maze))
+      (check ((m 'coin?) 1 1) "Cell (1,1) should be a coin")
+      (check (not ((m 'coin?) 0 0)) "Cell (0,0) should not be a coin"))
+
+    ;; Test door detection
+    (define (test-door)
+      (define m (make-maze))
+      (check ((m 'door?) 4 3) "Cell (4,3) should be a door")
+      (check (not ((m 'door?) 1 1)) "Cell (1,1) should not be a door"))
+
+    ;; Test cell-set! and remove-door!
+    (define (test-mutation)
+      (define m (make-maze))
+      ((m 'remove-door!) 4 3)
+      (check ((m 'empty?) 4 3) "Cell (4,3) should be empty after remove-door!")
+      (check (not ((m 'door?) 4 3)) "Cell (4,3) should no longer be a door"))
+
+    ;; Test that wall blocks movement
+    (define (test-wall-blocks)
+      (define m (make-maze))
+      (check ((m 'wall?) 1 0) "Cell (1,0) is a wall, Pac-Man cannot pass"))
+
+    (define (test)
+      (run-test test-dimensions "Maze: dimensions")
+      (run-test test-wall "Maze: wall detection")
+      (run-test test-coin "Maze: coin detection")
+      (run-test test-door "Maze: door detection")
+      (run-test test-mutation "Maze: cell mutation")
+      (run-test test-wall-blocks "Maze: wall blocks movement"))))

pacman-project/tests/test-pacman.rkt

@@ -1,51 +1,51 @@
 #lang r7rs
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                           Tests: Pac-Man ADT                              ;;
+;;                          Tests: Pac-Man ADT                               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (define-library (pacman-project tests test-pacman)
   (import (scheme base)
           (pp1 tests)
-          (pacman-project adt-positie)
+          (pacman-project adt-position)
           (pacman-project adt-pacman))
   (export test)
 
   (begin
 
-    ;; Test aanmaak en startpositie
-    (define (test-aanmaak)
-      (define pac (maak-pacman 5 2))
-      (define pos (pac 'positie))
-      (check-eq? (pos 'rij) 5 "Start rij moet 5 zijn")
-      (check-eq? (pos 'kolom) 2 "Start kolom moet 2 zijn"))
+    ;; Test creation and start position
+    (define (test-creation)
+      (define pac (make-pacman 5 2))
+      (define pos (pac 'position))
+      (check-eq? (pos 'row) 5 "Start row should be 5")
+      (check-eq? (pos 'col) 2 "Start col should be 2"))
 
-    ;; Test richting
-    (define (test-richting)
-      (define pac (maak-pacman 5 2))
-      (check-eq? (pac 'richting) 'rechts "Startrichting moet rechts zijn")
-      ((pac 'richting!) 'links)
-      (check-eq? (pac 'richting) 'links "Richting moet links zijn na richting!"))
+    ;; Test direction
+    (define (test-direction)
+      (define pac (make-pacman 5 2))
+      (check-eq? (pac 'direction) 'right "Start direction should be right")
+      ((pac 'direction!) 'left)
+      (check-eq? (pac 'direction) 'left "Direction should be left after direction!"))
 
-    ;; Test beweeg!
-    (define (test-beweeg)
-      (define pac (maak-pacman 5 2))
-      ((pac 'beweeg!) 0 1)
-      (define pos (pac 'positie))
-      (check-eq? (pos 'kolom) 3 "Kolom moet 3 zijn na 1 stap rechts")
-      (check-eq? (pos 'rij) 5 "Rij ongewijzigd na horizontale beweging"))
+    ;; Test move!
+    (define (test-move)
+      (define pac (make-pacman 5 2))
+      ((pac 'move!) 0 1)
+      (define pos (pac 'position))
+      (check-eq? (pos 'col) 3 "Col should be 3 after 1 step right")
+      (check-eq? (pos 'row) 5 "Row unchanged after horizontal move"))
 
-    ;; Test meerdere bewegingen
-    (define (test-meerdere-bewegingen)
-      (define pac (maak-pacman 5 5))
-      ((pac 'beweeg!) -1 0)
-      ((pac 'beweeg!) 0 1)
-      (define pos (pac 'positie))
-      (check-eq? (pos 'rij) 4 "Rij moet 4 zijn na omhoog")
-      (check-eq? (pos 'kolom) 6 "Kolom moet 6 zijn na rechts"))
+    ;; Test multiple moves
+    (define (test-multiple-moves)
+      (define pac (make-pacman 5 5))
+      ((pac 'move!) -1 0)
+      ((pac 'move!) 0 1)
+      (define pos (pac 'position))
+      (check-eq? (pos 'row) 4 "Row should be 4 after up")
+      (check-eq? (pos 'col) 6 "Col should be 6 after right"))
 
     (define (test)
-      (run-test test-aanmaak "Pac-Man: aanmaak en startpositie")
-      (run-test test-richting "Pac-Man: richting")
-      (run-test test-beweeg "Pac-Man: beweeg!")
-      (run-test test-meerdere-bewegingen "Pac-Man: meerdere bewegingen"))))
+      (run-test test-creation "Pac-Man: creation and start position")
+      (run-test test-direction "Pac-Man: direction")
+      (run-test test-move "Pac-Man: move!")
+      (run-test test-multiple-moves "Pac-Man: multiple moves"))))

pacman-project/tests/test-positie.rkt

@@ -1,57 +0,0 @@
-#lang r7rs
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                            Tests: Positie ADT                             ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(define-library (pacman-project tests test-positie)
-  (import (scheme base)
-          (pp1 tests)
-          (pacman-project adt-positie))
-  (export test)
-
-  (begin
-
-    ;; Test aanmaak en getters
-    (define (test-aanmaak)
-      (define pos (maak-positie 5 10))
-      (check-eq? (pos 'rij) 5 "Rij moet 5 zijn")
-      (check-eq? (pos 'kolom) 10 "Kolom moet 10 zijn"))
-
-    ;; Test mutators
-    (define (test-mutators)
-      (define pos (maak-positie 0 0))
-      ((pos 'rij!) 3)
-      ((pos 'kolom!) 7)
-      (check-eq? (pos 'rij) 3 "Rij moet 3 zijn na rij!")
-      (check-eq? (pos 'kolom) 7 "Kolom moet 7 zijn na kolom!"))
-
-    ;; Test vergelijk?
-    (define (test-vergelijk)
-      (define p1 (maak-positie 5 10))
-      (define p2 (maak-positie 5 10))
-      (define p3 (maak-positie 5 11))
-      (check ((p1 'vergelijk?) p2) "Gelijke posities moeten gelijk zijn")
-      (check (not ((p1 'vergelijk?) p3)) "Verschillende posities mogen niet gelijk zijn"))
-
-    ;; Test beweeg
-    (define (test-beweeg)
-      (define pos (maak-positie 5 10))
-      (define nieuwe-pos ((pos 'beweeg) -1 0))
-      (check-eq? (nieuwe-pos 'rij) 4 "Rij moet 4 zijn na beweeg omhoog")
-      (check-eq? (nieuwe-pos 'kolom) 10 "Kolom ongewijzigd na beweeg omhoog")
-      ;; Originele positie mag niet gewijzigd zijn
-      (check-eq? (pos 'rij) 5 "Originele rij mag niet wijzigen"))
-
-    ;; Test dat twee objecten niet eq? zijn
-    (define (test-identiteit)
-      (define p1 (maak-positie 1 1))
-      (define p2 (maak-positie 1 1))
-      (check (not (eq? p1 p2)) "Twee positie-objecten mogen niet eq? zijn"))
-
-    (define (test)
-      (run-test test-aanmaak "Positie: aanmaak en getters")
-      (run-test test-mutators "Positie: mutators")
-      (run-test test-vergelijk "Positie: vergelijk?")
-      (run-test test-beweeg "Positie: beweeg")
-      (run-test test-identiteit "Positie: identiteit"))))

pacman-project/tests/test-position.rkt

@@ -0,0 +1,57 @@
+#lang r7rs
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                           Tests: Position ADT                             ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-library (pacman-project tests test-position)
+  (import (scheme base)
+          (pp1 tests)
+          (pacman-project adt-position))
+  (export test)
+
+  (begin
+
+    ;; Test creation and getters
+    (define (test-creation)
+      (define pos (make-position 5 10))
+      (check-eq? (pos 'row) 5 "Row should be 5")
+      (check-eq? (pos 'col) 10 "Col should be 10"))
+
+    ;; Test mutators
+    (define (test-mutators)
+      (define pos (make-position 0 0))
+      ((pos 'row!) 3)
+      ((pos 'col!) 7)
+      (check-eq? (pos 'row) 3 "Row should be 3 after row!")
+      (check-eq? (pos 'col) 7 "Col should be 7 after col!"))
+
+    ;; Test equal?
+    (define (test-equal)
+      (define p1 (make-position 5 10))
+      (define p2 (make-position 5 10))
+      (define p3 (make-position 5 11))
+      (check ((p1 'equal?) p2) "Equal positions should match")
+      (check (not ((p1 'equal?) p3)) "Different positions should not match"))
+
+    ;; Test move
+    (define (test-move)
+      (define pos (make-position 5 10))
+      (define new-pos ((pos 'move) -1 0))
+      (check-eq? (new-pos 'row) 4 "Row should be 4 after move up")
+      (check-eq? (new-pos 'col) 10 "Col unchanged after move up")
+      ;; Original position must not change
+      (check-eq? (pos 'row) 5 "Original row must not change"))
+
+    ;; Test that two objects are not eq?
+    (define (test-identity)
+      (define p1 (make-position 1 1))
+      (define p2 (make-position 1 1))
+      (check (not (eq? p1 p2)) "Two position objects must not be eq?"))
+
+    (define (test)
+      (run-test test-creation "Position: creation and getters")
+      (run-test test-mutators "Position: mutators")
+      (run-test test-equal "Position: equal?")
+      (run-test test-move "Position: move")
+      (run-test test-identity "Position: identity"))))

pacman-project/tests/test-score.rkt

@@ -1,30 +0,0 @@
-#lang r7rs
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                            Tests: Score ADT                               ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(define-library (pacman-project tests test-score)
-  (import (scheme base)
-          (pp1 tests)
-          (pacman-project adt-score))
-  (export test)
-
-  (begin
-
-    ;; Test startscore
-    (define (test-startscore)
-      (define s (maak-score))
-      (check-eq? (s 'punten) 0 "Startscore moet 0 zijn"))
-
-    ;; Test score verhoging
-    (define (test-verhoog)
-      (define s (maak-score))
-      ((s 'verhoog!))
-      (check-eq? (s 'punten) 10 "Score moet 10 zijn na 1 muntje")
-      ((s 'verhoog!))
-      (check-eq? (s 'punten) 20 "Score moet 20 zijn na 2 muntjes"))
-
-    (define (test)
-      (run-test test-startscore "Score: startscore")
-      (run-test test-verhoog "Score: verhoging"))))

pacman-project/tests/test-tijdslimiet.rkt

@@ -1,55 +0,0 @@
-#lang r7rs
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                         Tests: Tijdslimiet ADT                            ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(define-library (pacman-project tests test-tijdslimiet)
-  (import (scheme base)
-          (pp1 tests)
-          (pacman-project adt-tijdslimiet))
-  (export test)
-
-  (begin
-
-    ;; Test starttijd
-    (define (test-starttijd)
-      (define t (maak-tijdslimiet))
-      (check-eq? (t 'resterende-tijd) 60 "Starttijd moet 60 seconden zijn")
-      (check (not ((t 'tijd-op?))) "Tijd mag niet op zijn bij start"))
-
-    ;; Test verlaag na 1 seconde
-    (define (test-verlaag)
-      (define t (maak-tijdslimiet))
-      ((t 'verlaag!) 1000)
-      (check-eq? (t 'resterende-tijd) 59 "Tijd moet 59 zijn na 1 seconde"))
-
-    ;; Test verhoog (muntje bonus)
-    (define (test-verhoog)
-      (define t (maak-tijdslimiet))
-      ((t 'verlaag!) 1000)
-      ((t 'verhoog!))
-      (check-eq? (t 'resterende-tijd) 60 "Tijd moet 60 zijn na verlaag + verhoog"))
-
-    ;; Test formatteer-tijd
-    (define (test-formatteer)
-      (define t (maak-tijdslimiet))
-      (check-eq? ((t 'formatteer-tijd)) "1:00" "60 seconden = 1:00")
-      ((t 'verlaag!) 1000)
-      (check-eq? ((t 'formatteer-tijd)) "0:59" "59 seconden = 0:59"))
-
-    ;; Test tijd-op?
-    (define (test-tijd-op)
-      (define t (maak-tijdslimiet))
-      ;; 60 keer verlagen met 1 seconde
-      (do ((i 0 (+ i 1)))
-        ((= i 60))
-        ((t 'verlaag!) 1000))
-      (check ((t 'tijd-op?)) "Tijd moet op zijn na 60 seconden"))
-
-    (define (test)
-      (run-test test-starttijd "Tijdslimiet: starttijd")
-      (run-test test-verlaag "Tijdslimiet: verlaag")
-      (run-test test-verhoog "Tijdslimiet: verhoog")
-      (run-test test-formatteer "Tijdslimiet: formatteer-tijd")
-      (run-test test-tijd-op "Tijdslimiet: tijd-op?"))))

pacman-project/tests/test-timer.rkt

@@ -0,0 +1,55 @@
+#lang r7rs
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                           Tests: Timer ADT                                ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-library (pacman-project tests test-timer)
+  (import (scheme base)
+          (pp1 tests)
+          (pacman-project adt-timer))
+  (export test)
+
+  (begin
+
+    ;; Test initial time
+    (define (test-initial)
+      (define t (make-timer))
+      (check-eq? (t 'remaining-time) 60 "Initial time should be 60 seconds")
+      (check (not ((t 'time-up?))) "Time should not be up at start"))
+
+    ;; Test decrease after 1 second
+    (define (test-decrease)
+      (define t (make-timer))
+      ((t 'decrease!) 1000)
+      (check-eq? (t 'remaining-time) 59 "Time should be 59 after 1 second"))
+
+    ;; Test increase (coin bonus)
+    (define (test-increase)
+      (define t (make-timer))
+      ((t 'decrease!) 1000)
+      ((t 'increase!))
+      (check-eq? (t 'remaining-time) 60 "Time should be 60 after decrease + increase"))
+
+    ;; Test format-time
+    (define (test-format)
+      (define t (make-timer))
+      (check-eq? ((t 'format-time)) "1:00" "60 seconds = 1:00")
+      ((t 'decrease!) 1000)
+      (check-eq? ((t 'format-time)) "0:59" "59 seconds = 0:59"))
+
+    ;; Test time-up?
+    (define (test-time-up)
+      (define t (make-timer))
+      ;; Decrease 60 times by 1 second
+      (do ((i 0 (+ i 1)))
+        ((= i 60))
+        ((t 'decrease!) 1000))
+      (check ((t 'time-up?)) "Time should be up after 60 seconds"))
+
+    (define (test)
+      (run-test test-initial "Timer: initial time")
+      (run-test test-decrease "Timer: decrease")
+      (run-test test-increase "Timer: increase")
+      (run-test test-format "Timer: format-time")
+      (run-test test-time-up "Timer: time-up?"))))