kamikazechaser/vise
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP implement high-level pagination test

Browse Source
This commit is contained in:
lash 2023-04-10 16:12:22 +01:00
parent 0831a4ea53
commit 5f04698d0a
Signed by untrusted user who does not match committer: lash
GPG Key ID: 21D2E7BB88C2A746
8 changed files with 60 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
go/dev/interactive.go
View File

@ -12,13 +12,15 @@ import (
func main() {
var dir string
var root string
var size uint
flag.StringVar(&dir, "d", ".", "resource dir to read from")
flag.UintVar(&size, "s", 0, "max size of output")
flag.StringVar(&root, "root", "root", "entry point symbol")
flag.Parse()
fmt.Fprintf(os.Stderr, "starting session at symbol '%s' using resource dir: %s\n", root, dir)
ctx := context.Background()
en := engine.NewDefaultEngine(dir)
en := engine.NewSizedEngine(dir, uint32(size))
err := engine.Loop(&en, root, ctx, os.Stdin, os.Stdout)
if err != nil {
fmt.Fprintf(os.Stderr, "loop exited with error: %v", err)

12
go/engine/default.go
View File

@ -10,5 +10,15 @@ func NewDefaultEngine(dir string) Engine {
st := state.NewState(0)
rs := resource.NewFsResource(dir)
ca := cache.NewCache()
return NewEngine(&st, &rs, ca)
return NewEngine(Config{}, &st, &rs, ca)
}
func NewSizedEngine(dir string, size uint32) Engine {
st := state.NewState(0)
rs := resource.NewFsResource(dir)
ca := cache.NewCache()
cfg := Config{
OutputSize: size,
}
return NewEngine(cfg, &st, &rs, ca)
}

14
go/engine/engine.go
View File

@ -7,15 +7,17 @@ import (
"log"
"git.defalsify.org/festive/cache"
"git.defalsify.org/festive/render"
"git.defalsify.org/festive/resource"
"git.defalsify.org/festive/state"
"git.defalsify.org/festive/vm"
)
//type Config struct {
type Config struct {
OutputSize uint32
// FlagCount uint32
// CacheSize uint32
//}
}
// Engine is an execution engine that handles top-level errors when running user inputs against currently exposed bytecode.
type Engine struct {
@ -26,12 +28,16 @@ type Engine struct {
}
// NewEngine creates a new Engine
func NewEngine(st *state.State, rs resource.Resource, ca cache.Memory) Engine {
func NewEngine(cfg Config, st *state.State, rs resource.Resource, ca cache.Memory) Engine {
var szr *render.Sizer
if cfg.OutputSize > 0 {
szr = render.NewSizer(cfg.OutputSize)
}
engine := Engine{
st: st,
rs: rs,
ca: ca,
vm: vm.NewVm(st, rs, ca, nil),
vm: vm.NewVm(st, rs, ca, szr),
}
return engine
}

8
go/engine/engine_test.go
View File

@ -75,7 +75,7 @@ func TestEngineInit(t *testing.T) {
rs := NewFsWrapper(dataDir, &st)
ca := cache.NewCache().WithCacheSize(1024)
en := NewEngine(&st, &rs, ca)
en := NewEngine(Config{}, &st, &rs, ca)
err := en.Init("root", ctx)
if err != nil {
t.Fatal(err)
@ -114,7 +114,9 @@ func TestEngineInit(t *testing.T) {
it has more lines
0:to foo
1:go bar`
1:go bar
2:see long`
if !bytes.Equal(b, []byte(expect)) {
t.Fatalf("expected\n\t%s\ngot:\n\t%s\n", expect, b)
}
@ -127,7 +129,7 @@ func TestEngineExecInvalidInput(t *testing.T) {
rs := NewFsWrapper(dataDir, &st)
ca := cache.NewCache().WithCacheSize(1024)
en := NewEngine(&st, &rs, ca)
en := NewEngine(Config{}, &st, &rs, ca)
err := en.Init("root", ctx)
if err != nil {
t.Fatal(err)

2
go/engine/loop_test.go
View File

@ -20,7 +20,7 @@ func TestLoopCorrect(t *testing.T) {
rs := resource.NewFsResource(dataDir)
ca := cache.NewCache().WithCacheSize(1024)
en := NewEngine(&st, &rs, ca)
en := NewEngine(Config{}, &st, &rs, ca)
err := en.Init("root", ctx)
if err != nil {
t.Fatal(err)

2
go/render/size.go
View File

@ -38,7 +38,6 @@ func(szr *Sizer) Set(key string, size uint16) error {
}
func(szr *Sizer) Check(s string) (uint32, bool) {
log.Printf("sizercheck %s", s)
l := uint32(len(s))
if szr.outputSize > 0 {
if l > szr.outputSize {
@ -84,7 +83,6 @@ func(szr *Sizer) GetAt(values map[string]string, idx uint16) (map[string]string,
c := szr.crsrs[idx]
v = v[c:]
nl := strings.Index(v, "\n")
log.Printf("k %v v %v c %v nl %v", k, v, c, nl)
if nl > 0 {
v = v[:nl]
}

31
go/testdata/testdata.go vendored
View File

@ -66,10 +66,12 @@ func foo() error {
b := []byte{}
b = vm.NewLine(b, vm.MOUT, []string{"0", "to foo"}, nil, nil)
b = vm.NewLine(b, vm.MOUT, []string{"1", "go bar"}, nil, nil)
b = vm.NewLine(b, vm.MOUT, []string{"2", "see long"}, nil, nil)
b = vm.NewLine(b, vm.LOAD, []string{"inky"}, []byte{20}, nil)
b = vm.NewLine(b, vm.HALT, nil, nil, nil)
b = vm.NewLine(b, vm.INCMP, []string{"0", "_"}, nil, nil)
b = vm.NewLine(b, vm.INCMP, []string{"1", "baz"}, nil, nil)
b = vm.NewLine(b, vm.INCMP, []string{"2", "long"}, nil, nil)
//b = vm.NewLine(b, vm.CATCH, []string{"_catch"}, []byte{1}, []uint8{1})
data := make(map[string]string)
@ -106,6 +108,33 @@ func baz() error {
return out("baz", b, tpl, nil)
}
func long() error {
b := []byte{}
b = vm.NewLine(b, vm.LOAD, []string{"longdata"}, []byte{0x00}, nil)
b = vm.NewLine(b, vm.MAP, []string{"longdata"}, nil, nil)
b = vm.NewLine(b, vm.MOUT, []string{"0", "back"}, nil, nil)
b = vm.NewLine(b, vm.MNEXT, []string{"00", "nexxt"}, nil, nil)
b = vm.NewLine(b, vm.MPREV, []string{"11", "prevv"}, nil, nil)
b = vm.NewLine(b, vm.HALT, nil, nil, nil)
b = vm.NewLine(b, vm.INCMP, []string{"0", "_"}, nil, nil)
tpl := `data
{{.longdata}}`
data := make(map[string]string)
data["longdata"] = `INKY 12
PINKY 5555
BLINKY 3t7
CLYDE 11
TINKYWINKY 22
DIPSY 666
LALA 111
POO 222
`
return out("long", b, tpl, data)
}
func defaultCatch() error {
b := []byte{}
b = vm.NewLine(b, vm.MOUT, []string{"0", "back"}, nil, nil)
@ -123,7 +152,7 @@ func generate() error {
return err
}
fns := []genFunc{root, foo, bar, baz, defaultCatch}
fns := []genFunc{root, foo, bar, baz, long, defaultCatch}
for _, fn := range fns {
err = fn()
if err != nil {

1
go/vm/runner.go
View File

@ -209,7 +209,6 @@ func(vm *Vm) RunLoad(b []byte, ctx context.Context) ([]byte, error) {
if err != nil {
return b, err
}
r, err := refresh(sym, vm.rs, ctx)
if err != nil {
return b, err