go-vise

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

vm_test.go (3203B)

      1 package vm
      2 
      3 import (
      4 	"testing"
      5 )
      6 
      7 func TestParseNoArg(t *testing.T) {
      8 	b := NewLine(nil, HALT, nil, nil, nil)
      9 	_, b, _ = opSplit(b)
     10 	b, err := ParseHalt(b)
     11 	if err != nil {
     12 		t.Fatal(err)
     13 	}
     14 	if len(b) > 0 {
     15 		t.Fatalf("expected empty code")
     16 	}
     17 }
     18 
     19 func TestParseSym(t *testing.T) {
     20 	b := NewLine(nil, MAP, []string{"baz"}, nil, nil)
     21 	_, b, _ = opSplit(b)
     22 	sym, b, err := ParseMap(b)
     23 	if err != nil {
     24 		t.Fatal(err)
     25 	}
     26 	if sym != "baz" {
     27 		t.Fatalf("expected sym baz, got %v", sym)
     28 	}
     29 	if len(b) > 0 {
     30 		t.Fatalf("expected empty code")
     31 	}
     32 
     33 	b = NewLine(nil, RELOAD, []string{"xyzzy"}, nil, nil)
     34 	_, b, _ = opSplit(b)
     35 	sym, b, err = ParseReload(b)
     36 	if err != nil {
     37 		t.Fatal(err)
     38 	}
     39 	if sym != "xyzzy" {
     40 		t.Fatalf("expected sym xyzzy, got %v", sym)
     41 	}
     42 	if len(b) > 0 {
     43 		t.Fatalf("expected empty code")
     44 	}
     45 
     46 	b = NewLine(nil, MOVE, []string{"plugh"}, nil, nil)
     47 	_, b, _ = opSplit(b)
     48 	sym, b, err = ParseMove(b)
     49 	if err != nil {
     50 		t.Fatal(err)
     51 	}
     52 	if sym != "plugh" {
     53 		t.Fatalf("expected sym plugh, got %v", sym)
     54 	}
     55 	if len(b) > 0 {
     56 		t.Fatalf("expected empty code")
     57 	}
     58 }
     59 
     60 func TestParseTwoSym(t *testing.T) {
     61 	b := NewLine(nil, INCMP, []string{"foo", "bar"}, nil, nil)
     62 	_, b, _ = opSplit(b)
     63 	one, two, b, err := ParseInCmp(b)
     64 	if err != nil {
     65 		t.Fatal(err)
     66 	}
     67 	if one != "foo" {
     68 		t.Fatalf("expected symone foo, got %v", one)
     69 	}
     70 	if two != "bar" {
     71 		t.Fatalf("expected symtwo bar, got %v", two)
     72 	}
     73 	if len(b) > 0 {
     74 		t.Fatalf("expected empty code")
     75 	}
     76 }
     77 
     78 func TestParseSig(t *testing.T) {
     79 	b := NewLine(nil, CROAK, nil, []byte{0x0b, 0x13}, []uint8{0x04})
     80 	_, b, _ = opSplit(b)
     81 	n, m, b, err := ParseCroak(b)
     82 	if err != nil {
     83 		t.Fatal(err)
     84 	}
     85 	if n != 2835 {
     86 		t.Fatalf("expected n 13, got %v", n)
     87 	}
     88 	if !m {
     89 		t.Fatalf("expected m true")
     90 	}
     91 	if len(b) > 0 {
     92 		t.Fatalf("expected empty code")
     93 	}
     94 }
     95 
     96 func TestParseSymSig(t *testing.T) {
     97 	b := NewLine(nil, CATCH, []string{"baz"}, []byte{0x0a, 0x13}, []uint8{0x01})
     98 	_, b, _ = opSplit(b)
     99 	sym, n, m, b, err := ParseCatch(b)
    100 	if err != nil {
    101 		t.Fatal(err)
    102 	}
    103 	if sym != "baz" {
    104 		t.Fatalf("expected sym baz, got %v", sym)
    105 	}
    106 	if n != 2579 {
    107 		t.Fatalf("expected n 13, got %v", n)
    108 	}
    109 	if !m {
    110 		t.Fatalf("expected m true")
    111 	}
    112 	if len(b) > 0 {
    113 		t.Fatalf("expected empty code")
    114 	}
    115 }
    116 
    117 func TestParseSymAndLen(t *testing.T) {
    118 	b := NewLine(nil, LOAD, []string{"foo"}, []byte{0x2a}, nil)
    119 	_, b, _ = opSplit(b)
    120 	sym, n, b, err := ParseLoad(b)
    121 	if err != nil {
    122 		t.Fatal(err)
    123 	}
    124 	if sym != "foo" {
    125 		t.Fatalf("expected sym foo, got %v", sym)
    126 	}
    127 	if n != 42 {
    128 		t.Fatalf("expected n 42, got %v", n)
    129 	}
    130 
    131 	b = NewLine(nil, LOAD, []string{"bar"}, []byte{0x02, 0x9a}, nil)
    132 	_, b, _ = opSplit(b)
    133 	sym, n, b, err = ParseLoad(b)
    134 	if err != nil {
    135 		t.Fatal(err)
    136 	}
    137 	if sym != "bar" {
    138 		t.Fatalf("expected sym foo, got %v", sym)
    139 	}
    140 	if n != 666 {
    141 		t.Fatalf("expected n 666, got %v", n)
    142 	}
    143 	if len(b) > 0 {
    144 		t.Fatalf("expected empty code")
    145 	}
    146 
    147 	b = NewLine(nil, LOAD, []string{"baz"}, []byte{0x0}, nil)
    148 	_, b, _ = opSplit(b)
    149 	sym, n, b, err = ParseLoad(b)
    150 	if err != nil {
    151 		t.Fatal(err)
    152 	}
    153 	if sym != "baz" {
    154 		t.Fatalf("expected sym foo, got %v", sym)
    155 	}
    156 	if n != 0 {
    157 		t.Fatalf("expected n 666, got %v", n)
    158 	}
    159 	if len(b) > 0 {
    160 		t.Fatalf("expected empty code")
    161 	}
    162 }