government / cmd / govlisp / readline_test.go

@ 2dbe47969d09d4856796bbf662b4e11c74a7f4fe | history


package main

import (
	"bytes"
	"io"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"

	"github.com/ergochat/readline"

	"government/eval"
)

// fakeTerminal runs readline over in as if it were a terminal, so a test
// can type keys at it: "\r" is Enter, "\t" is Tab, "\x03" is Ctrl-C.
func fakeTerminal(t *testing.T, in string) (*readlineSource, *eval.TopLevel, *bytes.Buffer, string) {
	t.Helper()
	var out bytes.Buffer
	history := filepath.Join(t.TempDir(), "history")
	top := eval.NewTopLevel()
	src, err := newReadlineSource(&readline.Config{
		Stdin:              strings.NewReader(in),
		Stdout:             &out,
		HistoryFile:        history,
		FuncIsTerminal:     func() bool { return true },
		FuncMakeRaw:        func() error { return nil },
		FuncExitRaw:        func() error { return nil },
		FuncGetSize:        func() (int, int) { return 80, 24 },
		FuncOnWidthChanged: func(func()) {},
	}, top)
	if err != nil {
		t.Fatal(err)
	}
	return src, top, &out, history
}

func TestReadlineREPL(t *testing.T) {
	keys := "(define fact (lambda (n)\r" +
		"\t(if (== n 0) 1 (* n (fact (- n 1))))))\r" +
		"(fa\t 10)\r" +
		"(car\x03" +
		"(+ 1\r2)\r"
	src, top, out, history := fakeTerminal(t, keys)
	repl(top, src, out)
	src.Close()

	got := out.String()
	for _, want := range []string{"gov> ", "...> ", "3628800\n", "^C", "3\n"} {
		if !strings.Contains(got, want) {
			t.Errorf("output lacks %q:\n%q", want, got)
		}
	}
	if strings.Contains(got, "E-") || strings.Contains(got, "syntax error") {
		t.Errorf("an error in the session (Ctrl-C should have dropped \"(car\"):\n%q", got)
	}
	data, err := os.ReadFile(history)
	if err != nil {
		t.Fatal(err)
	}
	lines := strings.Split(strings.TrimSpace(string(data)), "\n")
	want := []string{
		"(define fact (lambda (n)",
		"  (if (== n 0) 1 (* n (fact (- n 1))))))",
		"(fact 10)",
		"(+ 1",
		"2)",
	}
	if !reflect.DeepEqual(lines, want) {
		t.Errorf("history %q\nwant %q", lines, want)
	}
}

func TestCompleter(t *testing.T) {
	top := eval.NewTopLevel()
	forms := "(define square (lambda (n) (* n n)))"
	runREPLWith(t, top, forms)
	c := completer{top}
	tests := []struct {
		line   string
		want   []string
		length int
	}{
		{"(squ", []string{"are"}, 3},
		{"(la", []string{"mbda"}, 2},
		{"(ca", []string{"r"}, 2},
		{"(car", nil, 3},
		{"'(cd", []string{"r"}, 2},
		{"", []string{indent}, 0},
		{"(+ 1 ", []string{indent}, 0},
		{"(zzz", nil, 3},
	}
	for _, tt := range tests {
		got, length := c.Do([]rune(tt.line), len([]rune(tt.line)))
		var words []string
		for _, r := range got {
			words = append(words, string(r))
		}
		if !reflect.DeepEqual(words, tt.want) || length != tt.length {
			t.Errorf("%q: %q, %d; want %q, %d", tt.line, words, length, tt.want, tt.length)
		}
	}
}

func runREPLWith(t *testing.T, top *eval.TopLevel, input string) {
	t.Helper()
	repl(top, newPlainSource(strings.NewReader(input)), io.Discard)
}