feat: add more real world tests (#477)

* Add euc / oob / shf / stp examples

These examples are not yet complete, however, as they require test
traces as well.

* Add MMIO example

Again, this is not yet complete because we don't have traces for it.

* Add real-world traces

These are based off the unit tests used for the linea-tracer.

This second batch of traces are appended and include traces taken from
the replay tests.

Makefile

@@ -22,7 +22,7 @@ lint:
 .PHONY: test
 test:
 	@echo ">>> Running Unit Tests..."
-	go test -v -race ./...
+	go test --timeout 0 -v ./...
 
 .PHONY: qtest
 qtest:

pkg/sexp/translator.go

@@ -1,6 +1,9 @@
 package sexp
 
-import "fmt"
+import (
+	"fmt"
+	"reflect"
+)
 
 // SymbolRule is a symbol generator is responsible for converting a terminating
 // expression (i.e. a symbol) into an expression type T.  For
@@ -265,7 +268,9 @@ func translateSExp[T comparable](p *Translator[T], s SExp) (T, []SyntaxError) {
 		}
 	}
 	// This should be unreachable.
-	return empty, p.SyntaxErrors(s, "invalid s-expression")
+	typeof := reflect.TypeOf(s)
+	// But, if it is reached ... produce a nice error :)
+	return empty, p.SyntaxErrors(s, fmt.Sprintf("invalid s-expression (%s)", typeof))
 }
 
 // Translate a list of S-Expressions into a unary, binary or n-ary

pkg/test/valid_corset_test.go

@@ -660,6 +660,11 @@ func Test_PureFun_08(t *testing.T) {
 	Check(t, false, "purefun_08")
 }
 
+/* #479
+func Test_PureFun_09(t *testing.T) {
+	Check(t, false, "purefun_0")
+}
+*/
 // ===================================================================
 // For Loops
 // ===================================================================
@@ -764,8 +769,8 @@ func TestSlow_BinStatic(t *testing.T) {
 	Check(t, true, "bin-static")
 }
 
-func TestSlow_BinDynamic(t *testing.T) {
-	Check(t, true, "bin-dynamic")
+func TestSlow_Bin(t *testing.T) {
+	Check(t, true, "bin")
 }
 
 func TestSlow_Wcp(t *testing.T) {
@@ -776,6 +781,28 @@ func TestSlow_Wcp(t *testing.T) {
 	Check(t, true, "mxp")
 }
 */
+/*
+	 func TestSlow_Shf(t *testing.T) {
+		Check(t, true, "shf")
+	}
+*/
+func TestSlow_Euc(t *testing.T) {
+	Check(t, true, "euc")
+}
+
+/*
+	 func TestSlow_Oob(t *testing.T) {
+		Check(t, true, "oob")
+	}
+*/
+func TestSlow_Stp(t *testing.T) {
+	Check(t, true, "stp")
+}
+
+/* func TestSlow_Mmio(t *testing.T) {
+	Check(t, true, "mmio")
+}
+*/
 // ===================================================================
 // Test Helpers
 // ===================================================================
@@ -808,14 +835,17 @@ func Check(t *testing.T, stdlib bool, test string) {
 	// Check valid traces are accepted
 	accepts_file := fmt.Sprintf("%s/%s.%s", TestDir, test, "accepts")
 	accepts := ReadTracesFile(accepts_file)
+	ntests := len(accepts)
 	CheckTraces(t, accepts_file, true, true, accepts, schema)
 	// Check invalid traces are rejected
 	rejects_file := fmt.Sprintf("%s/%s.%s", TestDir, test, "rejects")
 	rejects := ReadTracesFile(rejects_file)
+	ntests += len(rejects)
 	CheckTraces(t, rejects_file, false, true, rejects, schema)
 	// Check expanded traces are rejected
 	expands_file := fmt.Sprintf("%s/%s.%s", TestDir, test, "expanded")
 	expands := ReadTracesFile(expands_file)
+	ntests += len(expands)
 	CheckTraces(t, expands_file, false, false, expands, schema)
 	// Check auto-generated valid traces (if applicable)
 	auto_accepts_file := fmt.Sprintf("%s/%s.%s", TestDir, test, "auto.accepts")
@@ -827,6 +857,10 @@ func Check(t *testing.T, stdlib bool, test string) {
 	if auto_rejects := ReadTracesFileIfExists(auto_rejects_file); auto_rejects != nil {
 		CheckTraces(t, auto_rejects_file, false, true, auto_rejects, schema)
 	}
+	//
+	if ntests == 0 {
+		panic(fmt.Sprintf("missing any tests for %s", test))
+	}
 }
 
 // Check a given set of tests have an expected outcome (i.e. are

testdata/euc.lisp

@@ -0,0 +1,56 @@
+(module euc)
+
+(defcolumns
+  (IOMF :binary@prove)
+  (CT :i8)
+  (CT_MAX :i8)
+  (DIVIDEND :i64)
+  (DIVISOR :i64)
+  (QUOTIENT :i64)
+  (REMAINDER :i64)
+  (CEIL :i64)
+  (DONE :binary)
+  (DIVISOR_BYTE :byte@prove)
+  (QUOTIENT_BYTE :byte@prove)
+  (REMAINDER_BYTE :byte@prove))
+
+(defconst
+  MMEDIUM                                   8)
+
+(module euc)
+
+(defconst
+  MAX_INPUT_LENGTH MMEDIUM)
+
+(defconstraint first-row (:domain {0})
+  (vanishes! IOMF))
+
+(defconstraint heartbeat ()
+  (if-zero IOMF
+           (begin (vanishes! DONE)
+                  (vanishes! (next CT)))
+           (begin (eq! (next IOMF) 1)
+                  (if-zero (- CT_MAX CT)
+                           (begin (eq! DONE 1)
+                                  (vanishes! (next CT)))
+                           (begin (vanishes! DONE)
+                                  (will-inc! CT 1))))))
+
+(defconstraint ctmax ()
+  (eq! (~ (- CT MAX_INPUT_LENGTH))
+       1))
+
+(defconstraint counter-constancies ()
+  (counter-constancy CT CT_MAX))
+
+(defconstraint byte-decomposition ()
+  (begin (byte-decomposition CT DIVISOR DIVISOR_BYTE)
+         (byte-decomposition CT QUOTIENT QUOTIENT_BYTE)
+         (byte-decomposition CT REMAINDER REMAINDER_BYTE)))
+
+(defconstraint result (:guard DONE)
+  (begin (eq! DIVIDEND
+              (+ (* DIVISOR QUOTIENT) REMAINDER))
+         (if-zero (* DIVIDEND REMAINDER)
+                  (eq! CEIL QUOTIENT)
+                  (eq! CEIL (+ QUOTIENT 1)))))