go-vise

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

debug_test.go (4097B)

      1 package vm
      2 
      3 import (
      4 	"testing"
      5 )
      6 
      7 func TestToString(t *testing.T) {
      8 	var b []byte
      9 	var r string
     10 	var expect string
     11 	var err error
     12 
     13 	ph := NewParseHandler().WithDefaultHandlers()
     14 	b = NewLine(nil, CATCH, []string{"xyzzy"}, []byte{0x0d}, []uint8{1})
     15 	r, err = ph.ToString(b)
     16 	if err != nil {
     17 		t.Fatal(err)
     18 	}
     19 	expect = "CATCH xyzzy 13 1\n"
     20 	if r != expect {
     21 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     22 	}
     23 
     24 	b = NewLine(nil, CROAK, nil, []byte{0x0d}, []uint8{1})
     25 	r, err = ph.ToString(b)
     26 	if err != nil {
     27 		t.Fatal(err)
     28 	}
     29 	expect = "CROAK 13 1\n"
     30 	if r != expect {
     31 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     32 	}
     33 
     34 	b = NewLine(nil, LOAD, []string{"foo"}, []byte{0x0a}, nil)
     35 	r, err = ph.ToString(b)
     36 	if err != nil {
     37 		t.Fatal(err)
     38 	}
     39 	expect = "LOAD foo 10\n"
     40 	if r != expect {
     41 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     42 	}
     43 
     44 	b = NewLine(nil, RELOAD, []string{"bar"}, nil, nil)
     45 	r, err = ph.ToString(b)
     46 	if err != nil {
     47 		t.Fatal(err)
     48 	}
     49 	expect = "RELOAD bar\n"
     50 	if r != expect {
     51 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     52 	}
     53 
     54 	b = NewLine(nil, MAP, []string{"inky_pinky"}, nil, nil)
     55 	r, err = ph.ToString(b)
     56 	if err != nil {
     57 		t.Fatal(err)
     58 	}
     59 	expect = "MAP inky_pinky\n"
     60 	if r != expect {
     61 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     62 	}
     63 
     64 	b = NewLine(nil, MOVE, []string{"blinky_clyde"}, nil, nil)
     65 	r, err = ph.ToString(b)
     66 	if err != nil {
     67 		t.Fatal(err)
     68 	}
     69 	expect = "MOVE blinky_clyde\n"
     70 	if r != expect {
     71 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     72 	}
     73 
     74 	b = NewLine(nil, HALT, nil, nil, nil)
     75 	r, err = ph.ToString(b)
     76 	if err != nil {
     77 		t.Fatal(err)
     78 	}
     79 	expect = "HALT\n"
     80 	if r != expect {
     81 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     82 	}
     83 
     84 	b = NewLine(nil, INCMP, []string{"13", "baz"}, nil, nil)
     85 	r, err = ph.ToString(b)
     86 	if err != nil {
     87 		t.Fatal(err)
     88 	}
     89 	expect = "INCMP 13 baz\n"
     90 	if r != expect {
     91 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
     92 	}
     93 
     94 	b = NewLine(nil, MNEXT, []string{"11", "nextmenu"}, nil, nil)
     95 	r, err = ph.ToString(b)
     96 	if err != nil {
     97 		t.Fatal(err)
     98 	}
     99 	//expect = "MNEXT 11 \"nextmenu\"\n"
    100 	expect = "MNEXT 11 nextmenu\n"
    101 	if r != expect {
    102 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
    103 	}
    104 
    105 	b = NewLine(nil, MPREV, []string{"222", "previous menu item"}, nil, nil)
    106 	r, err = ph.ToString(b)
    107 	if err != nil {
    108 		t.Fatal(err)
    109 	}
    110 	//expect = "MPREV 222 \"previous menu item\"\n"
    111 	expect = "MPREV 222 previous menu item\n"
    112 	if r != expect {
    113 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
    114 	}
    115 
    116 	b = NewLine(nil, MOUT, []string{"1", "foo"}, nil, nil)
    117 	r, err = ph.ToString(b)
    118 	if err != nil {
    119 		t.Fatal(err)
    120 	}
    121 	//expect = "MOUT 1 \"foo\"\n"
    122 	expect = "MOUT 1 foo\n"
    123 	if r != expect {
    124 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
    125 	}
    126 
    127 	b = NewLine(nil, MSINK, nil, nil, nil) //[]uint8{0x42, 0x2a})
    128 	r, err = ph.ToString(b)
    129 	if err != nil {
    130 		t.Fatal(err)
    131 	}
    132 	//expect = "MSIZE 66 42\n"
    133 	expect = "MSINK\n"
    134 	if r != expect {
    135 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
    136 	}
    137 }
    138 
    139 func TestToStringMultiple(t *testing.T) {
    140 	ph := NewParseHandler().WithDefaultHandlers()
    141 	b := NewLine(nil, INCMP, []string{"1", "foo"}, nil, nil)
    142 	b = NewLine(b, INCMP, []string{"2", "bar"}, nil, nil)
    143 	b = NewLine(b, CATCH, []string{"aiee"}, []byte{0x02, 0x9a}, []uint8{0})
    144 	b = NewLine(b, LOAD, []string{"inky"}, []byte{0x2a}, nil)
    145 	b = NewLine(b, HALT, nil, nil, nil)
    146 	r, err := ph.ToString(b)
    147 	if err != nil {
    148 		t.Fatal(err)
    149 	}
    150 	expect := `INCMP 1 foo
    151 INCMP 2 bar
    152 CATCH aiee 666 0
    153 LOAD inky 42
    154 HALT
    155 `
    156 	if r != expect {
    157 		t.Fatalf("expected:\n\t%v\ngot:\n\t%v", expect, r)
    158 	}
    159 }
    160 
    161 func TestVerifyMultiple(t *testing.T) {
    162 	ph := NewParseHandler().WithDefaultHandlers()
    163 	b := NewLine(nil, INCMP, []string{"1", "foo"}, nil, nil)
    164 	b = NewLine(b, INCMP, []string{"2", "bar"}, nil, nil)
    165 	b = NewLine(b, CATCH, []string{"aiee"}, []byte{0x02, 0x9a}, []uint8{0})
    166 	b = NewLine(b, LOAD, []string{"inky"}, []byte{0x2a}, nil)
    167 	b = NewLine(b, HALT, nil, nil, nil)
    168 	n, err := ph.ParseAll(b)
    169 	if err != nil {
    170 		t.Fatal(err)
    171 	}
    172 	if n != 0 {
    173 		t.Fatalf("expected write count to be 0, was %v (how is that possible)", n)
    174 	}
    175 }