go-vise

Constrained Size Output Virtual Machine
Info | Log | Files | Refs | README | LICENSE

input_test.go (3086B)

      1 package vm
      2 
      3 import (
      4 	"context"
      5 	"testing"
      6 
      7 	"git.defalsify.org/vise.git/state"
      8 	"git.defalsify.org/vise.git/cache"
      9 )
     10 
     11 func TestPhoneInput(t *testing.T) {
     12 	v, err := ValidInput([]byte("+12345"))
     13 	if err != nil {
     14 		t.Fatal(err)
     15 	}
     16 	if v != -1 {
     17 		t.Fatalf("expected -1, got %d", v)
     18 	}
     19 }
     20 
     21 func TestMenuInputs(t *testing.T) {
     22 	var err error
     23 	_, err = ValidInput([]byte("0"))
     24 	if err != nil {
     25 		t.Fatal(err)
     26 	}
     27 
     28 	_, err = ValidInput([]byte("99"))
     29 	if err != nil {
     30 		t.Fatal(err)
     31 	}
     32 
     33 	_, err = ValidInput([]byte("foo"))
     34 	if err != nil {
     35 		t.Fatal(err)
     36 	}
     37 
     38 	_, err = ValidInput([]byte("foo Bar"))
     39 	if err != nil {
     40 		t.Fatal(err)
     41 	}
     42 }
     43 
     44 func TestFalseInput(t *testing.T) {
     45 	_, err := ValidInput([]byte{0x0a})
     46 	if err == nil {
     47 		t.Fatal("expected error")
     48 	}
     49 }
     50 
     51 func TestTargetInput(t *testing.T) {
     52 	var err error
     53 	st := state.NewState(1)
     54 	_, err = CheckTarget([]byte(""), st)
     55 	if err == nil {
     56 		t.Fatal("expected error")
     57 	}
     58 	_, err = CheckTarget([]byte("_"), st)
     59 	if err == nil {
     60 		t.Fatal("expected error")
     61 	}
     62 	st.Down("foo")
     63 	v, err := CheckTarget([]byte("_"), st)
     64 	if err != nil {
     65 		t.Fatal(err)
     66 	}
     67 	if !v {
     68 		t.Fatal("expected true")
     69 	}
     70 	v, err = CheckTarget([]byte("<"), st)
     71 	if err != nil {
     72 		t.Fatal(err)
     73 	}
     74 	if v {
     75 		t.Fatal("expected false")
     76 	}
     77 	v, err = CheckTarget([]byte(">"), st)
     78 	if err != nil {
     79 		t.Fatal(err)
     80 	}
     81 	if !v {
     82 		t.Fatal("expected true")
     83 	}
     84 	v, err = CheckTarget([]byte("%"), st)
     85 	if err == nil {
     86 		t.Fatal("expected error")
     87 	}
     88 	v, err = CheckTarget([]byte("foo"), st)
     89 	if err != nil {
     90 		t.Fatal(err)
     91 	}
     92 	if !v {
     93 		t.Fatal("expected true")
     94 	}
     95 }
     96 
     97 func TestApplyTarget(t *testing.T) {
     98 	var err error
     99 	ctx := context.Background()
    100 	st := state.NewState(0)
    101 	st.Down("root")
    102 	st.Down("one")
    103 	st.Down("two")
    104 	ca := cache.NewCache()
    105 	rs := newTestResource(st)
    106 	rs.Lock()
    107 	b := NewLine(nil, INCMP, []string{"^", "0"}, nil, nil)
    108 	vm := NewVm(st, rs, ca, nil)
    109 
    110 	st.SetInput([]byte("0"))
    111 	b, err = vm.Run(ctx, b)
    112 	if err != nil {
    113 		t.Fatal(err)
    114 	}
    115 
    116 	st.Restart()
    117 	st.Down("foo")
    118 	b = NewLine(nil, INCMP, []string{"_", "0"}, nil, nil)
    119 	vm = NewVm(st, rs, ca, nil)
    120 
    121 	st.SetInput([]byte("0"))
    122 	b, err = vm.Run(ctx, b)
    123 	if err != nil {
    124 		t.Fatal(err)
    125 	}
    126 
    127 	st.Restart()
    128 	b = NewLine(nil, INCMP, []string{".", "0"}, nil, nil)
    129 	vm = NewVm(st, rs, ca, nil)
    130 
    131 	st.SetInput([]byte("0"))
    132 	b, err = vm.Run(ctx, b)
    133 	if err != nil {
    134 		t.Fatal(err)
    135 	}
    136 
    137 	st.Restart()
    138 	b = NewLine(nil, INCMP, []string{">", "0"}, nil, nil)
    139 	vm = NewVm(st, rs, ca, nil)
    140 
    141 	st.SetInput([]byte("0"))
    142 	b, err = vm.Run(ctx, b)
    143 	if err != nil {
    144 		t.Fatal(err)
    145 	}
    146 
    147 	st.Restart()
    148 	b = NewLine(nil, INCMP, []string{"<", "0"}, nil, nil)
    149 	vm = NewVm(st, rs, ca, nil)
    150 
    151 	st.SetInput([]byte("0"))
    152 	b, err = vm.Run(ctx, b)
    153 	if err != nil {
    154 		t.Fatal(err)
    155 	}
    156 }
    157 
    158 func TestVmCustomInputValid(t *testing.T) {
    159 	var err error
    160 	s := []byte{0x07, 0x6a, 0x6f, 0x6f}
    161 	_, err = ValidInput(s)
    162 	if err == nil {
    163 		t.Fatal("expected error")
    164 	}
    165 
    166 	err = RegisterInputValidator(42, "^\x07[a-z]+")
    167 	if err != nil {
    168 		t.Fatal(err)
    169 	}
    170 
    171 	v, err := ValidInput(s)
    172 	if err != nil {
    173 		t.Fatal(err)
    174 	}
    175 	if v != 42 {
    176 		t.Fatalf("expected 42, got %d", v)
    177 	}
    178 }