government / src / program / program_test.go

@ 425eee5ae0d898d1e8c0558a56c41f58d7a05028 | history


package program

import (
	"bytes"
	"errors"
	"strings"
	"testing"
	"time"

	"nmyk.io/government/lisp2gov"
	"nmyk.io/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)
	}
}