@ ce159ec40272fb3caed2436702b1426f1550e47d | history
package program
import (
"bytes"
"errors"
"strings"
"testing"
"time"
"government/lisp2gov"
"government/ratify"
)
var now = time.Date(2026, 11, 14, 0, 0, 0, 0, time.UTC)
func load(t *testing.T, src string) *Program {
t.Helper()
data, err := lisp2gov.Compile(src, lisp2gov.Options{})
if err != nil {
t.Fatal(err)
}
p, err := Load(data, Options{At: now})
if err != nil {
t.Fatal(err)
}
return p
}
func TestRun(t *testing.T) {
p := load(t, "(define sq (lambda (x) (* x x))) (sq 12) \"done\"")
var out bytes.Buffer
if err := p.Run(&out); err != nil {
t.Fatal(err)
}
if got, want := out.String(), "144\n\"done\"\n"; got != want {
t.Errorf("output %q, want %q", got, want)
}
}
func TestErrorsNameTheirOID(t *testing.T) {
// Node ids: (#1 define#2 f#3 (#4 lambda#5 (#6 x#7) (#8 +#9 x#10 z#11)))
// (#12 f#13 1#14). The failing list is (+ x z), node 8, at depth 3.
p := load(t, "(define f (lambda (x) (+ x z))) (f 1)")
err := p.Run(&bytes.Buffer{})
if err == nil {
t.Fatal("no error")
}
got := p.Describe(err)
want := "E-UNBOUND: no statute for symbol z at GOV.0.8.1 (depth 3)"
if got != want {
t.Errorf("got %s\nwant %s", got, want)
}
}
func TestLoadRefusals(t *testing.T) {
data, err := lisp2gov.Compile("(+ 1 2)", lisp2gov.Options{})
if err != nil {
t.Fatal(err)
}
if _, err := Load(data, Options{At: time.Date(1999, 1, 1, 0, 0, 0, 0, time.UTC)}); !hasCode(err, ratify.ErrNotInForce) {
t.Errorf("before the window: %v", err)
}
pin, _ := ratify.LoadPin(data)
seed := [32]byte{9}
other, _ := lisp2gov.Compile("(+ 1 2)", lisp2gov.Options{Seed: &seed})
if _, err := Load(other, Options{At: now, Pin: pin}); !hasCode(err, ratify.ErrForeign) {
t.Errorf("foreign: %v", err)
}
if _, err := Load(data, Options{At: now, MaxNodes: 2}); err == nil || !strings.Contains(err.Error(), "E-TOO-LARGE") {
t.Errorf("budget: %v", err)
}
}
func hasCode(err error, code string) bool {
var e *ratify.Error
return errors.As(err, &e) && e.Code == code
}
func TestErrorsNameTheirNote(t *testing.T) {
src := "; compute the total\n(define total (lambda (xs)\n (+ (car xs) z)))\n(total '(1))"
p := load(t, src)
err := p.Run(&bytes.Buffer{})
got := p.Describe(err)
if !strings.HasSuffix(got, `(note: "compute the total")`) {
t.Errorf("got %s", got)
}
// The innermost noted node wins.
p = load(t, "; outer\n(define f (lambda ()\n ; inner\n (+ 1 z)))\n(f)")
if got := p.Describe(p.Run(&bytes.Buffer{})); !strings.HasSuffix(got, `(note: "inner")`) {
t.Errorf("got %s", got)
}
}