118 - persist all test traces

1 files changed, 60 insertions, 0 deletions

diff --git a/mu.arc.t b/mu.arc.t
index 75bbbd1d..b5226f49 100644
--- a/mu.arc.t
+++ b/mu.arc.t
@@ -1,6 +1,7 @@
 (load "mu.arc")
 
 (reset)
+(new-trace "literal")
 (add-fns
   '((test1
       ((1 integer) <- copy (23 literal)))))
@@ -11,6 +12,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "add")
 (add-fns
   '((test1
       ((1 integer) <- copy (1 literal))
@@ -21,6 +23,7 @@
   (prn "F - 'add' operates on two addresses"))
 
 (reset)
+(new-trace "new-fn")
 (add-fns
   '((test1
       ((3 integer) <- add (1 integer) (2 integer)))
@@ -35,6 +38,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "new-fn-once")
 (add-fns
   '((test1
       ((1 integer) <- copy (1 literal)))
@@ -45,6 +49,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "new-fn-reply")
 (add-fns
   '((test1
       ((3 integer) <- add (1 integer) (2 integer))
@@ -61,6 +66,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "new-fn-reply-nested")
 (add-fns
   `((test1
       ((3 integer) <- test2))
@@ -76,6 +82,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "new-fn-reply-once")
 (add-fns
   '((test1
       ((3 integer) <- add (1 integer) (2 integer))
@@ -90,6 +97,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "new-fn-arg-sequential")
 (add-fns
   '((test1
       ((4 integer) <- arg)
@@ -111,6 +119,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "new-fn-arg-random-access")
 (add-fns
   '((test1
       ((5 integer) <- arg 1)
@@ -135,6 +144,7 @@
 ; how should errors be handled? will be unclear until we support concurrency and routine trees.
 
 (reset)
+(new-trace "new-fn-reply-oarg")
 (add-fns
   '((test1
       ((4 integer) <- arg)
@@ -154,6 +164,7 @@
   (prn "F - 'reply' can take aguments that are returned, or written back into output args of caller"))
 
 (reset)
+(new-trace "new-fn-reply-oarg-multiple")
 (add-fns
   '((test1
       ((4 integer) <- arg)
@@ -173,6 +184,7 @@
   (prn "F - 'reply' permits a function to return multiple values at once"))
 
 (reset)
+(new-trace "add-literal")
 (add-fns
   '((test1
       ((1 integer) <- add (2 literal) (3 literal)))))
@@ -181,6 +193,7 @@
   (prn "F - ops can take 'literal' operands (but not return them)"))
 
 (reset)
+(new-trace "sub-literal")
 (add-fns
   '((main
       ((1 integer) <- sub (1 literal) (3 literal)))))
@@ -190,6 +203,7 @@
   (prn "F - 'sub' subtracts the value at one address from the value at another"))
 
 (reset)
+(new-trace "mul-literal")
 (add-fns
   '((main
       ((1 integer) <- mul (2 literal) (3 literal)))))
@@ -199,6 +213,7 @@
   (prn "F - 'mul' multiplies like 'add' adds"))
 
 (reset)
+(new-trace "div-literal")
 (add-fns
   '((main
       ((1 integer) <- div (8 literal) (3 literal)))))
@@ -208,6 +223,7 @@
   (prn "F - 'div' divides like 'add' adds"))
 
 (reset)
+(new-trace "idiv-literal")
 (add-fns
   '((main
       ((1 integer) (2 integer) <- idiv (8 literal) (3 literal)))))
@@ -217,6 +233,7 @@
   (prn "F - 'idiv' performs integer division, returning quotient and remainder"))
 
 (reset)
+(new-trace "and-literal")
 (add-fns
   '((main
       ((1 boolean) <- and (t literal) (nil literal)))))
@@ -226,6 +243,7 @@
   (prn "F - logical 'and' for booleans"))
 
 (reset)
+(new-trace "lt-literal")
 (add-fns
   '((main
       ((1 boolean) <- lt (4 literal) (3 literal)))))
@@ -235,6 +253,7 @@
   (prn "F - 'lt' is the less-than inequality operator"))
 
 (reset)
+(new-trace "le-literal-false")
 (add-fns
   '((main
       ((1 boolean) <- le (4 literal) (3 literal)))))
@@ -244,6 +263,7 @@
   (prn "F - 'le' is the <= inequality operator"))
 
 (reset)
+(new-trace "le-literal-true")
 (add-fns
   '((main
       ((1 boolean) <- le (4 literal) (4 literal)))))
@@ -253,6 +273,7 @@
   (prn "F - 'le' returns true for equal operands"))
 
 (reset)
+(new-trace "le-literal-true-2")
 (add-fns
   '((main
       ((1 boolean) <- le (4 literal) (5 literal)))))
@@ -262,6 +283,7 @@
   (prn "F - le is the <= inequality operator - 2"))
 
 (reset)
+(new-trace "jmp-skip")
 (add-fns
   '((main
       ((1 integer) <- copy (8 literal))
@@ -274,6 +296,7 @@
   (prn "F - 'jmp' skips some instructions"))
 
 (reset)
+(new-trace "jmp-target")
 (add-fns
   '((main
       ((1 integer) <- copy (8 literal))
@@ -288,6 +311,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "jif-skip")
 (add-fns
   '((main
       ((2 integer) <- copy (1 literal))
@@ -302,6 +326,7 @@
   (prn "F - 'jif' is a conditional 'jmp'"))
 
 (reset)
+(new-trace "jif-fallthrough")
 (add-fns
   '((main
       ((1 boolean) <- eq (1 literal) (2 literal))
@@ -315,6 +340,7 @@
   (prn "F - if 'jif's first arg is false, it doesn't skip any instructions"))
 
 (reset)
+(new-trace "jif-backward")
 (add-fns
   '((main
       ((1 integer) <- copy (2 literal))
@@ -332,6 +358,7 @@
   (prn "F - 'jif' can take a negative offset to make backward jumps"))
 
 (reset)
+(new-trace "direct-addressing")
 (add-fns
   '((main
       ((1 integer) <- copy (34 literal))
@@ -342,6 +369,7 @@
   (prn "F - 'copy' performs direct addressing"))
 
 (reset)
+(new-trace "indirect-addressing")
 (add-fns
   '((main
       ((1 integer-address) <- copy (2 literal))
@@ -353,6 +381,7 @@
   (prn "F - 'copy' performs indirect addressing"))
 
 (reset)
+(new-trace "indirect-addressing-oarg")
 (add-fns
   '((main
       ((1 integer-address) <- copy (2 literal))
@@ -364,6 +393,7 @@
   (prn "F - instructions can perform indirect addressing on output arg"))
 
 (reset)
+(new-trace "get-record")
 (add-fns
   '((main
       ((1 integer) <- copy (34 literal))
@@ -376,6 +406,7 @@
   (prn "F - 'get' accesses fields of records"))
 
 (reset)
+(new-trace "get-indirect")
 (add-fns
   '((main
       ((1 integer) <- copy (34 literal))
@@ -389,6 +420,7 @@
   (prn "F - 'get' accesses fields of record address"))
 
 (reset)
+(new-trace "get-compound-field")
 (add-fns
   '((main
       ((1 integer) <- copy (34 literal))
@@ -401,6 +433,7 @@
   (prn "F - 'get' accesses fields spanning multiple locations"))
 
 (reset)
+(new-trace "get-address")
 (add-fns
   '((main
       ((1 integer) <- copy (34 literal))
@@ -412,6 +445,7 @@
   (prn "F - 'get-address' returns address of fields of records"))
 
 (reset)
+(new-trace "get-address-indirect")
 (add-fns
   '((main
       ((1 integer) <- copy (34 literal))
@@ -424,6 +458,7 @@
   (prn "F - 'get-address' accesses fields of record address"))
 
 (reset)
+(new-trace "index-array-literal")
 (add-fns
   '((main
       ((1 integer) <- copy (2 literal))
@@ -438,6 +473,7 @@
   (prn "F - 'index' accesses indices of arrays"))
 
 (reset)
+(new-trace "index-array-direct")
 (add-fns
   '((main
       ((1 integer) <- copy (2 literal))
@@ -453,6 +489,7 @@
   (prn "F - 'index' accesses indices of arrays"))
 
 (reset)
+(new-trace "index-address")
 (add-fns
   '((main
       ((1 integer) <- copy (2 literal))
@@ -468,6 +505,7 @@
   (prn "F - 'index-address' returns addresses of indices of arrays"))
 
 (reset)
+(new-trace "len-array")
 (add-fns
   '((main
       ((1 integer) <- copy (2 literal))
@@ -482,6 +520,7 @@
   (prn "F - 'len' accesses length of array"))
 
 (reset)
+(new-trace "sizeof-record")
 (add-fns
   '((main
       ((1 integer) <- sizeof (integer-boolean-pair type)))))
@@ -491,6 +530,7 @@
   (prn "F - 'sizeof' returns space required by arg"))
 
 (reset)
+(new-trace "sizeof-record-not-len")
 (add-fns
   '((main
       ((1 integer) <- sizeof (integer-point-pair type)))))
@@ -502,6 +542,7 @@
 ; todo: test that out-of-bounds access throws an error
 
 (reset)
+(new-trace "compound-operand")
 (add-fns
   '((main
       ((1 integer) <- copy (34 literal))
@@ -514,6 +555,7 @@
   (prn "F - ops can operate on records spanning multiple locations"))
 
 (reset)
+(new-trace "dispatch-otype")
 (add-fns
   '((test1
       ((4 type) <- otype 0)
@@ -536,6 +578,7 @@
 ; todo - test that reply increments pc for caller frame after popping current frame
 
 (reset)
+(new-trace "dispatch-otype-multiple-clauses")
 (add-fns
   '((test-fn
       ((4 type) <- otype 0)
@@ -566,6 +609,7 @@
 ;? (quit)
 
 (reset)
+(new-trace "dispatch-otype-multiple-calls")
 (add-fns
   '((test-fn
       ((4 type) <- otype 0)
@@ -594,6 +638,8 @@
                        4 'integer  5 nil  6 3  7 4  8 7))
   (prn "F - different calls can exercise different clauses of the same function (internals)"))
 
+(reset)
+(new-trace "convert-braces")
 (if (~iso (convert-braces '(((1 integer) <- copy (4 literal))
                             ((2 integer) <- copy (2 literal))
                             ((3 integer) <- add (2 integer) (2 integer))
@@ -612,6 +658,8 @@
             (reply)))
   (prn "F - convert-braces replaces breakif with a jif to after the next close curly"))
 
+(reset)
+(new-trace "convert-braces-empty-block")
 (if (~iso (convert-braces '(((1 integer) <- copy (4 literal))
                             ((2 integer) <- copy (2 literal))
                             ((3 integer) <- add (2 integer) (2 integer))
@@ -626,6 +674,8 @@
             (reply)))
   (prn "F - convert-braces works for degenerate blocks"))
 
+(reset)
+(new-trace "convert-braces-nested-break")
 (if (~iso (convert-braces '(((1 integer) <- copy (4 literal))
                             ((2 integer) <- copy (2 literal))
                             ((3 integer) <- add (2 integer) (2 integer))
@@ -646,6 +696,8 @@
             (reply)))
   (prn "F - convert-braces balances curlies when converting break"))
 
+(reset)
+(new-trace "convert-braces-nested-continue")
 (if (~iso (convert-braces '(((1 integer) <- copy (4 literal))
                             ((2 integer) <- copy (2 literal))
                             { begin
@@ -667,6 +719,7 @@
   (prn "F - convert-braces balances curlies when converting continue"))
 
 (reset)
+(new-trace "continue")
 (add-fns `((main ,@(convert-braces '(((1 integer) <- copy (4 literal))
                                      ((2 integer) <- copy (1 literal))
                                      { begin
@@ -684,6 +737,7 @@
   (prn "F - continue correctly loops"))
 
 (reset)
+(new-trace "continue-fail")
 (add-fns `((main ,@(convert-braces '(((1 integer) <- copy (4 literal))
                                      ((2 integer) <- copy (2 literal))
                                      { begin
@@ -701,6 +755,7 @@
   (prn "F - continue might never trigger"))
 
 (reset)
+(new-trace "new-primitive")
 (let before Memory-in-use-until
   (add-fns
     '((main
@@ -713,6 +768,7 @@
     (prn "F - 'new' on primitive types increments high-water mark by their size")))
 
 (reset)
+(new-trace "new-array-literal")
 (let before Memory-in-use-until
   (add-fns
     '((main
@@ -725,6 +781,7 @@
     (prn "F - 'new' on primitive arrays increments high-water mark by their size")))
 
 (reset)
+(new-trace "new-array-direct")
 (let before Memory-in-use-until
   (add-fns
     '((main
@@ -738,6 +795,7 @@
     (prn "F - 'new' on primitive arrays increments high-water mark by their (variable) size")))
 
 (reset)
+(new-trace "scheduler")
 (add-fns
   '((f1
       ((1 integer) <- copy (3 literal)))
@@ -758,3 +816,5 @@
     ("schedule" "f2")
     ("run" "f2 0")
   ))
+
+(reset)