asm_test.go (11644B)
1 package asm 2 3 import ( 4 "bytes" 5 "encoding/hex" 6 "log" 7 "testing" 8 9 "git.defalsify.org/vise.git/vm" 10 ) 11 12 func TestParserRoute(t *testing.T) { 13 b := bytes.NewBuffer(nil) 14 s := "HALT\n" 15 Parse(s, b) 16 expect := vm.NewLine(nil, vm.HALT, nil, nil, nil) 17 if !bytes.Equal(b.Bytes(), expect) { 18 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 19 } 20 21 b = bytes.NewBuffer(nil) 22 s = "MSINK\n" 23 Parse(s, b) 24 expect = vm.NewLine(nil, vm.MSINK, nil, nil, nil) 25 if !bytes.Equal(b.Bytes(), expect) { 26 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 27 } 28 29 b = bytes.NewBuffer(nil) 30 s = "MAP tinkywinky\n" 31 Parse(s, b) 32 expect = vm.NewLine(nil, vm.MAP, []string{"tinkywinky"}, nil, nil) 33 if !bytes.Equal(b.Bytes(), expect) { 34 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 35 } 36 37 b = bytes.NewBuffer(nil) 38 s = "MOVE dipsy\n" 39 Parse(s, b) 40 expect = vm.NewLine(nil, vm.MOVE, []string{"dipsy"}, nil, nil) 41 if !bytes.Equal(b.Bytes(), expect) { 42 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 43 } 44 45 b = bytes.NewBuffer(nil) 46 s = "RELOAD lalapu\n" 47 Parse(s, b) 48 expect = vm.NewLine(nil, vm.RELOAD, []string{"lalapu"}, nil, nil) 49 if !bytes.Equal(b.Bytes(), expect) { 50 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 51 } 52 53 b = bytes.NewBuffer(nil) 54 s = "LOAD foo 42\n" 55 Parse(s, b) 56 expect = vm.NewLine(nil, vm.LOAD, []string{"foo"}, []byte{0x2a}, nil) 57 if !bytes.Equal(b.Bytes(), expect) { 58 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 59 } 60 61 b = bytes.NewBuffer(nil) 62 s = "MOUT foo bar\n" 63 Parse(s, b) 64 expect = vm.NewLine(nil, vm.MOUT, []string{"foo", "bar"}, nil, nil) 65 if !bytes.Equal(b.Bytes(), expect) { 66 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 67 } 68 69 b = bytes.NewBuffer(nil) 70 s = "MOUT baz 42\n" 71 Parse(s, b) 72 expect = vm.NewLine(nil, vm.MOUT, []string{"baz", "42"}, nil, nil) 73 if !bytes.Equal(b.Bytes(), expect) { 74 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 75 } 76 77 b = bytes.NewBuffer(nil) 78 s = "MNEXT inky 12\n" 79 Parse(s, b) 80 expect = vm.NewLine(nil, vm.MNEXT, []string{"inky", "12"}, nil, nil) 81 if !bytes.Equal(b.Bytes(), expect) { 82 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 83 } 84 85 b = bytes.NewBuffer(nil) 86 s = "MPREV pinky 34\n" 87 Parse(s, b) 88 expect = vm.NewLine(nil, vm.MPREV, []string{"pinky", "34"}, nil, nil) 89 if !bytes.Equal(b.Bytes(), expect) { 90 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 91 } 92 93 b = bytes.NewBuffer(nil) 94 s = "INCMP foo bar\n" 95 Parse(s, b) 96 expect = vm.NewLine(nil, vm.INCMP, []string{"foo", "bar"}, nil, nil) 97 if !bytes.Equal(b.Bytes(), expect) { 98 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 99 } 100 101 b = bytes.NewBuffer(nil) 102 s = "INCMP baz 42\n" 103 Parse(s, b) 104 expect = vm.NewLine(nil, vm.INCMP, []string{"baz", "42"}, nil, nil) 105 if !bytes.Equal(b.Bytes(), expect) { 106 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 107 } 108 109 b = bytes.NewBuffer(nil) 110 s = "INCMP xyzzy *\n" 111 Parse(s, b) 112 expect = vm.NewLine(nil, vm.INCMP, []string{"xyzzy", "*"}, nil, nil) 113 if !bytes.Equal(b.Bytes(), expect) { 114 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 115 } 116 117 b = bytes.NewBuffer(nil) 118 s = "DOWN foo 2 bar\n" 119 Parse(s, b) 120 expect = vm.NewLine(nil, vm.MOUT, []string{"bar", "2"}, nil, nil) 121 expect = vm.NewLine(expect, vm.HALT, nil, nil, nil) 122 expect = vm.NewLine(expect, vm.INCMP, []string{"foo", "2"}, nil, nil) 123 if !bytes.Equal(b.Bytes(), expect) { 124 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 125 } 126 127 b = bytes.NewBuffer(nil) 128 s = "UP 3 bar\n" 129 Parse(s, b) 130 expect = vm.NewLine(nil, vm.MOUT, []string{"bar", "3"}, nil, nil) 131 expect = vm.NewLine(expect, vm.HALT, nil, nil, nil) 132 expect = vm.NewLine(expect, vm.INCMP, []string{"_", "3"}, nil, nil) 133 if !bytes.Equal(b.Bytes(), expect) { 134 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 135 } 136 137 b = bytes.NewBuffer(nil) 138 s = "NEXT 4 baz\n" 139 Parse(s, b) 140 expect = vm.NewLine(nil, vm.MNEXT, []string{"baz", "4"}, nil, nil) 141 expect = vm.NewLine(expect, vm.HALT, nil, nil, nil) 142 expect = vm.NewLine(expect, vm.INCMP, []string{">", "4"}, nil, nil) 143 if !bytes.Equal(b.Bytes(), expect) { 144 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 145 } 146 147 b = bytes.NewBuffer(nil) 148 s = "PREVIOUS 5 xyzzy\n" 149 Parse(s, b) 150 expect = vm.NewLine(nil, vm.MPREV, []string{"xyzzy", "5"}, nil, nil) 151 expect = vm.NewLine(expect, vm.HALT, nil, nil, nil) 152 expect = vm.NewLine(expect, vm.INCMP, []string{"<", "5"}, nil, nil) 153 if !bytes.Equal(b.Bytes(), expect) { 154 log.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", expect, b) 155 } 156 157 } 158 159 func TestParserInit(t *testing.T) { 160 var b []byte 161 b = vm.NewLine(b, vm.HALT, nil, nil, nil) 162 b = vm.NewLine(b, vm.CATCH, []string{"xyzzy"}, []byte{0x02, 0x9a}, []uint8{1}) 163 b = vm.NewLine(b, vm.INCMP, []string{"pinky", "inky"}, nil, nil) 164 b = vm.NewLine(b, vm.LOAD, []string{"foo"}, []byte{42}, nil) 165 b = vm.NewLine(b, vm.MOUT, []string{"bar", "barbarbaz"}, nil, nil) 166 ph := vm.NewParseHandler().WithDefaultHandlers() 167 s, err := ph.ToString(b) 168 log.Printf("parsing:\n%s\n", s) 169 170 n, err := Parse(s, nil) 171 if err != nil { 172 t.Fatal(err) 173 } 174 if n != 0 { 175 t.Fatalf("expected 0 byte write count, got %v", n) 176 } 177 } 178 179 func TestParserSized(t *testing.T) { 180 var b []byte 181 b = vm.NewLine(b, vm.LOAD, []string{"foo"}, []byte{42}, nil) 182 ph := vm.NewParseHandler().WithDefaultHandlers() 183 s, err := ph.ToString(b) 184 log.Printf("parsing:\n%s\n", s) 185 186 r := bytes.NewBuffer(nil) 187 n, err := Parse(s, r) 188 if err != nil { 189 t.Fatal(err) 190 } 191 if n != 8 { 192 t.Fatalf("expected 8 byte write count, got %v", n) 193 } 194 rb := r.Bytes() 195 if !bytes.Equal(rb, []byte{0x00, vm.LOAD, 0x03, 0x66, 0x6f, 0x6f, 0x01, 0x2a}) { 196 t.Fatalf("expected 0x00%x012a, got %v", vm.LOAD, rb) 197 } 198 } 199 200 func TestParseDisplay(t *testing.T) { 201 var b []byte 202 b = vm.NewLine(b, vm.MOUT, []string{"foo", "baz_ba_zbaz"}, nil, nil) 203 ph := vm.NewParseHandler().WithDefaultHandlers() 204 s, err := ph.ToString(b) 205 log.Printf("parsing:\n%s\n", s) 206 207 r := bytes.NewBuffer(nil) 208 n, err := Parse(s, r) 209 if err != nil { 210 t.Fatal(err) 211 } 212 if n != 18 { 213 t.Fatalf("expected 18 byte write count, got %v", n) 214 } 215 rb := r.Bytes() 216 expect := []byte{0x00, vm.MOUT, 0x03, 0x66, 0x6f, 0x6f, 0x0b, 0x62, 0x61, 0x7a, 0x5f, 0x62, 0x61, 0x5f, 0x7a, 0x62, 0x61, 0x7a} 217 if !bytes.Equal(rb, expect) { 218 t.Fatalf("expected:\n\t%x\ngot:\n\t%x", expect, rb) 219 } 220 } 221 222 func TestParseDouble(t *testing.T) { 223 t.Skip("foo") 224 var b []byte 225 b = vm.NewLine(b, vm.INCMP, []string{"foo", "bar"}, nil, nil) 226 ph := vm.NewParseHandler().WithDefaultHandlers() 227 s, err := ph.ToString(b) 228 log.Printf("parsing:\n%s\n", s) 229 230 r := bytes.NewBuffer(nil) 231 n, err := Parse(s, r) 232 if err != nil { 233 t.Fatal(err) 234 } 235 if n != 10 { 236 t.Fatalf("expected 18 byte write count, got %v", n) 237 } 238 rb := r.Bytes() 239 expect := []byte{0x00, vm.INCMP, 0x03, 0x62, 0x61, 0x72, 0x03, 0x66, 0x6f, 0x6f} 240 if !bytes.Equal(rb, expect) { 241 t.Fatalf("expected %x, got %x", expect, rb) 242 } 243 } 244 245 func TestParseMenu(t *testing.T) { 246 s := `DOWN foobar 00 inky_pinky 247 UP s1 tinkywinky 248 UP 2 dipsy 249 ` 250 r := bytes.NewBuffer(nil) 251 n, err := Parse(s, r) 252 if err != nil { 253 t.Fatal(err) 254 } 255 log.Printf("wrote %v bytes", n) 256 257 s = `MOUT inky_pinky 00 258 MOUT tinkywinky s1 259 MOUT dipsy 2 260 HALT 261 INCMP foobar 00 262 INCMP _ s1 263 INCMP _ 2 264 ` 265 r_check := bytes.NewBuffer(nil) 266 n, err = Parse(s, r_check) 267 if err != nil { 268 t.Fatal(err) 269 } 270 log.Printf("wrote %v bytes", n) 271 272 if !bytes.Equal(r_check.Bytes(), r.Bytes()) { 273 t.Fatalf("expected:\n\t%x\ngot:\n\t%x\n", r_check, r) 274 } 275 276 } 277 278 func TestParseMenuZeroPrefix(t *testing.T) { 279 s := `INCMP ^ 00 280 ` 281 r := bytes.NewBuffer(nil) 282 n, err := Parse(s, r) 283 if err != nil { 284 t.Fatal(err) 285 } 286 log.Printf("wrote %v bytes", n) 287 288 } 289 290 func TestParseSingle(t *testing.T) { 291 var b []byte 292 b = vm.NewLine(b, vm.MAP, []string{"xyzzy"}, nil, nil) 293 ph := vm.NewParseHandler().WithDefaultHandlers() 294 s, err := ph.ToString(b) 295 log.Printf("parsing:\n%s\n", s) 296 297 r := bytes.NewBuffer(nil) 298 n, err := Parse(s, r) 299 if err != nil { 300 t.Fatal(err) 301 } 302 if n != 8 { 303 t.Fatalf("expected 8 byte write count, got %v", n) 304 } 305 rb := r.Bytes() 306 expect := []byte{0x00, vm.MAP, 0x05, 0x78, 0x79, 0x7a, 0x7a, 0x79} 307 if !bytes.Equal(rb, expect) { 308 t.Fatalf("expected %x, got %x", expect, rb) 309 } 310 } 311 312 func TestParseSig(t *testing.T) { 313 b := vm.NewLine(nil, vm.CATCH, []string{"plugh"}, []byte{0x02, 0x9a}, []uint8{0x2a}) 314 ph := vm.NewParseHandler().WithDefaultHandlers() 315 s, err := ph.ToString(b) 316 log.Printf("parsing:\n%s\n", s) 317 318 r := bytes.NewBuffer(nil) 319 n, err := Parse(s, r) 320 if err != nil { 321 t.Fatal(err) 322 } 323 if n != 12 { 324 t.Fatalf("expected 12 byte write count, got %v", n) 325 } 326 rb := r.Bytes() 327 expect_hex := "000105706c75676802029a01" 328 expect, err := hex.DecodeString(expect_hex) 329 if err != nil { 330 t.Fatal(err) 331 } 332 if !bytes.Equal(rb, expect) { 333 t.Fatalf("expected %v, got %x", expect_hex, rb) 334 } 335 336 b = vm.NewLine(nil, vm.CATCH, []string{"plugh"}, []byte{0x01}, []uint8{0x0}) 337 s, err = ph.ToString(b) 338 log.Printf("parsing:\n%s\n", s) 339 340 r = bytes.NewBuffer(nil) 341 n, err = Parse(s, r) 342 if err != nil { 343 t.Fatal(err) 344 } 345 if n != 11 { 346 t.Fatalf("expected 11 byte write count, got %v", n) 347 } 348 rb = r.Bytes() 349 expect_hex = "000105706c756768010100" 350 expect, err = hex.DecodeString(expect_hex) 351 if err != nil { 352 t.Fatal(err) 353 } 354 if !bytes.Equal(rb, expect) { 355 t.Fatalf("expected %v, got %x", expect_hex, rb) 356 } 357 } 358 359 func TestParseCroak(t *testing.T) { 360 b := bytes.NewBuffer(nil) 361 s := "CROAK 2 1\n" 362 Parse(s, b) 363 expect := vm.NewLine(nil, vm.CROAK, nil, []byte{0x02}, []uint8{0x1}) 364 if !bytes.Equal(b.Bytes(), expect) { 365 t.Fatalf("expected %x, got %x", expect, b) 366 } 367 } 368 369 func TestParseNoarg(t *testing.T) { 370 var b []byte 371 ph := vm.NewParseHandler().WithDefaultHandlers() 372 b = vm.NewLine(b, vm.HALT, nil, nil, nil) 373 s, err := ph.ToString(b) 374 log.Printf("parsing:\n%s\n", s) 375 376 r := bytes.NewBuffer(nil) 377 n, err := Parse(s, r) 378 if err != nil { 379 t.Fatal(err) 380 } 381 if n != 2 { 382 t.Fatalf("expected 8 byte write count, got %v", n) 383 } 384 rb := r.Bytes() 385 expect := []byte{0x00, vm.HALT} 386 if !bytes.Equal(rb, expect) { 387 t.Fatalf("expected %x, got %x", expect, rb) 388 } 389 } 390 391 func TestParserWriteMultiple(t *testing.T) { 392 var b []byte 393 b = vm.NewLine(b, vm.HALT, nil, nil, nil) 394 b = vm.NewLine(b, vm.CATCH, []string{"xyzzy"}, []byte{0x02, 0x9a}, []uint8{1}) 395 b = vm.NewLine(b, vm.INCMP, []string{"pinky", "inky"}, nil, nil) 396 b = vm.NewLine(b, vm.LOAD, []string{"foo"}, []byte{42}, nil) 397 b = vm.NewLine(b, vm.MOUT, []string{"bar", "bar_barb_az"}, nil, nil) 398 ph := vm.NewParseHandler().WithDefaultHandlers() 399 s, err := ph.ToString(b) 400 log.Printf("parsing:\n%s\n", s) 401 402 r := bytes.NewBuffer(nil) 403 n, err := Parse(s, r) 404 if err != nil { 405 t.Fatal(err) 406 } 407 log.Printf("result %x", r.Bytes()) 408 409 r_expect_hex := "000700010578797a7a7902029a0100080570696e6b7904696e6b79000303666f6f012a000a036261720b6261725f626172625f617a" 410 r_expect, err := hex.DecodeString(r_expect_hex) 411 if err != nil { 412 t.Fatal(err) 413 } 414 n_expect := len(r_expect) 415 if n != n_expect { 416 t.Fatalf("expected total %v bytes output, got %v", n_expect, n) 417 } 418 419 rb := r.Bytes() 420 if !bytes.Equal(rb, r_expect) { 421 t.Fatalf("expected result:\n\t%v, got:\n\t%x", r_expect_hex, rb) 422 } 423 424 _, err = ph.ParseAll(rb) 425 if err != nil { 426 t.Fatal(err) 427 } 428 } 429 430 func TestParserCapQuote(t *testing.T) { 431 t.Skip("please fix mysterious ignore of initial cap in display sym match") 432 b := vm.NewLine(nil, vm.MOUT, []string{"a", "foo"}, nil, nil) 433 b = vm.NewLine(b, vm.MOUT, []string{"b", "Bar"}, nil, nil) 434 b = vm.NewLine(b, vm.MOUT, []string{"c", "baz"}, nil, nil) 435 b = vm.NewLine(b, vm.MSINK, nil, nil, nil) 436 ph := vm.NewParseHandler().WithDefaultHandlers() 437 s, err := ph.ToString(b) 438 log.Printf("parsing:\n%s", s) 439 440 r := bytes.NewBuffer(nil) 441 n, err := Parse(s, r) 442 if err != nil { 443 t.Fatal(err) 444 } 445 _ = n 446 }