digi.rip / tachyon
brainfuck interpreter
brainfuck cli rust
5
Fork 0

Configure Feed

Select the types of activity you want to include in your feed.

evaluator: updated parse_brackets arguments in tests

digi.rip (Jun 9, 2026, 2:19 PM EDT) 2a5df86f 7a746d1c

+66 -46
+66 -46
src/evaluator.rs
··· 418 418 419 419 #[test] 420 420 fn data_pointer() { 421 - let tokens = tokenizer("+>++>+++-<-<-"); 422 - let map = parse_brackets(&tokens).unwrap(); 421 + let source = "+>++>+++-<-<-"; 422 + let tokens = tokenizer(source); 423 + let map = parse_brackets(&tokens, source).unwrap(); 423 424 let mut machine = VM::builder().tape(3).build(); 424 425 425 426 machine ··· 432 433 433 434 #[test] 434 435 fn data_pointer_oob_left() { 435 - let tokens = tokenizer("<"); 436 - let map = parse_brackets(&tokens).unwrap(); 436 + let source = "<"; 437 + let tokens = tokenizer(source); 438 + let map = parse_brackets(&tokens, source).unwrap(); 437 439 let mut machine = VM::builder().tape(1).build(); 438 440 let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty()); 439 441 ··· 443 445 444 446 #[test] 445 447 fn data_pointer_oob_right() { 446 - let tokens = tokenizer(">>>>"); 447 - let map = parse_brackets(&tokens).unwrap(); 448 + let source = ">>>>"; 449 + let tokens = tokenizer(source); 450 + let map = parse_brackets(&tokens, source).unwrap(); 448 451 let mut machine = VM::builder().tape(1).build(); 449 452 let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty()); 450 453 ··· 454 457 455 458 #[test] 456 459 fn increment() { 457 - let tokens = tokenizer("++++"); 458 - let map = parse_brackets(&tokens).unwrap(); 460 + let source = "++++"; 461 + let tokens = tokenizer(source); 462 + let map = parse_brackets(&tokens, source).unwrap(); 459 463 let mut machine = VM::builder().tape(1).build(); 460 464 461 465 machine ··· 466 470 467 471 #[test] 468 472 fn decrement() { 469 - let tokens = tokenizer("++++---"); 470 - let map = parse_brackets(&tokens).unwrap(); 473 + let source = "++++---"; 474 + let tokens = tokenizer(source); 475 + let map = parse_brackets(&tokens, source).unwrap(); 471 476 let mut machine = VM::builder().tape(1).build(); 472 477 473 478 machine ··· 481 486 // subtract first cell from 0 -> 255 482 487 // move to second cell, subtract from 0 -> 255, then add 483 488 // from 255 back to 0 484 - let tokens = tokenizer("->-+"); 485 - let map = parse_brackets(&tokens).unwrap(); 489 + let source = "->-+"; 490 + let tokens = tokenizer(source); 491 + let map = parse_brackets(&tokens, source).unwrap(); 486 492 let mut machine = VM::builder().tape(2).build(); 487 493 488 494 machine ··· 494 500 495 501 #[test] 496 502 fn input() { 497 - let tokens = tokenizer(","); 498 - let map = parse_brackets(&tokens).unwrap(); 503 + let source = ","; 504 + let tokens = tokenizer(source); 505 + let map = parse_brackets(&tokens, source).unwrap(); 499 506 let mut machine = VM::builder().tape(1).build(); 500 507 let fake_input = std::io::Cursor::new(b"A"); 501 508 ··· 507 514 508 515 #[test] 509 516 fn input_overflow() { 510 - let tokens = tokenizer(","); 511 - let map = parse_brackets(&tokens).unwrap(); 517 + let source = ","; 518 + let tokens = tokenizer(source); 519 + let map = parse_brackets(&tokens, source).unwrap(); 512 520 let mut machine = VM::builder().tape(1).build(); 513 521 let fake_input = std::io::Cursor::new(b"AB"); 514 522 ··· 520 528 521 529 #[test] 522 530 fn input_zero() { 523 - let tokens = tokenizer(","); 524 - let map = parse_brackets(&tokens).unwrap(); 531 + let source = ","; 532 + let tokens = tokenizer(source); 533 + let map = parse_brackets(&tokens, source).unwrap(); 525 534 let mut machine = VM::builder().tape(1).build(); 526 535 let fake_input = std::io::Cursor::new(b"0"); 527 536 ··· 533 542 534 543 #[test] 535 544 fn output() { 536 - let tokens = tokenizer(",."); 537 - let map = parse_brackets(&tokens).unwrap(); 545 + let source = ",."; 546 + let tokens = tokenizer(source); 547 + let map = parse_brackets(&tokens, source).unwrap(); 538 548 let mut machine = VM::builder().tape(1).build(); 539 549 let fake_input = std::io::Cursor::new(b"1"); 540 550 let mut capture_buffer: Vec<u8> = Vec::new(); ··· 547 557 548 558 #[test] 549 559 fn looping() { 550 - let tokens = tokenizer("+++[>+<-]>"); 551 - let map = parse_brackets(&tokens).unwrap(); 560 + let source = "+++[>+<-]>"; 561 + let tokens = tokenizer(source); 562 + let map = parse_brackets(&tokens, source).unwrap(); 552 563 let mut machine = VM::builder().tape(3).build(); 553 564 554 565 machine ··· 561 572 #[test] 562 573 fn loop_skips_next_inst() { 563 574 // making sure loop code isn't skipping 564 - let tokens = tokenizer("++[-]>++"); 565 - let map = parse_brackets(&tokens).unwrap(); 575 + let source = "++[-]>++"; 576 + let tokens = tokenizer(source); 577 + let map = parse_brackets(&tokens, source).unwrap(); 566 578 let mut machine = VM::builder().tape(2).build(); 567 579 568 580 machine ··· 575 587 576 588 #[test] 577 589 fn hello_world() { 578 - let tokens = tokenizer( 579 - "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.", 580 - ); 581 - let map = parse_brackets(&tokens).unwrap(); 590 + let source = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++."; 591 + let tokens = tokenizer(source); 592 + let map = parse_brackets(&tokens, source).unwrap(); 582 593 let mut machine = VM::builder().build(); 583 594 let mut capture_buffer: Vec<u8> = Vec::new(); 584 595 ··· 591 602 592 603 #[test] 593 604 fn repeat() { 594 - let tokens = tokenizer(",>,[<.>-]"); 595 - let map = parse_brackets(&tokens).unwrap(); 605 + let source = ",>,[<.>-]"; 606 + let tokens = tokenizer(source); 607 + let map = parse_brackets(&tokens, source).unwrap(); 596 608 let mut machine = VM::builder().build(); 597 609 let mut capture_buffer: Vec<u8> = Vec::new(); 598 610 let fake_input = std::io::Cursor::new(b"A\nB"); ··· 607 619 608 620 #[test] 609 621 fn nesting_loops() { 610 - let tokens = tokenizer("[[][]]"); 611 - let map = parse_brackets(&tokens).unwrap(); 622 + let source = "[[][]]"; 623 + let tokens = tokenizer(source); 624 + let map = parse_brackets(&tokens, source).unwrap(); 612 625 let mut machine = VM::builder().tape(1).build(); 613 626 let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty()); 614 627 ··· 617 630 618 631 #[test] 619 632 fn data_pointer_wrap_right() { 620 - let tokens = tokenizer(">"); 621 - let map = parse_brackets(&tokens).unwrap(); 633 + let source = ">"; 634 + let tokens = tokenizer(source); 635 + let map = parse_brackets(&tokens, source).unwrap(); 622 636 let mut machine = VM::builder().tape(1).data_oob(OOBBehavior::Wrap).build(); 623 637 let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty()); 624 638 assert!(result.is_ok()); ··· 627 641 628 642 #[test] 629 643 fn data_pointer_wrap_left() { 630 - let tokens = tokenizer("<"); 631 - let map = parse_brackets(&tokens).unwrap(); 644 + let source = "<"; 645 + let tokens = tokenizer(source); 646 + let map = parse_brackets(&tokens, source).unwrap(); 632 647 let mut machine = VM::builder().tape(1).data_oob(OOBBehavior::Wrap).build(); 633 648 let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty()); 634 649 assert!(result.is_ok()); ··· 637 652 638 653 #[test] 639 654 fn cell_oob_error_increment() { 640 - let tokens = tokenizer("-+"); 641 - let map = parse_brackets(&tokens).unwrap(); 655 + let source = "-+"; 656 + let tokens = tokenizer(source); 657 + let map = parse_brackets(&tokens, source).unwrap(); 642 658 let mut machine = VM::builder().tape(1).cell_oob(OOBBehavior::Error).build(); 643 659 let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty()); 644 660 eprintln!("{}", result.as_ref().unwrap_err()); ··· 647 663 648 664 #[test] 649 665 fn cell_oob_error_decrement() { 650 - let tokens = tokenizer(&"+".repeat(256)); 651 - let map = parse_brackets(&tokens).unwrap(); 666 + let source = &"+".repeat(256); 667 + let tokens = tokenizer(source); 668 + let map = parse_brackets(&tokens, source).unwrap(); 652 669 let mut machine = VM::builder().tape(1).cell_oob(OOBBehavior::Error).build(); 653 670 let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty()); 654 671 eprintln!("{}", result.as_ref().unwrap_err()); ··· 657 674 658 675 #[test] 659 676 fn read_raw() { 660 - let tokens = tokenizer(","); 661 - let map = parse_brackets(&tokens).unwrap(); 677 + let source = ","; 678 + let tokens = tokenizer(source); 679 + let map = parse_brackets(&tokens, source).unwrap(); 662 680 let mut machine = VM::builder().tape(1).input_type(IOFormat::Raw).build(); 663 681 let fake_input = std::io::Cursor::new("1"); 664 682 machine ··· 669 687 670 688 #[test] 671 689 fn write_raw() { 672 - let tokens = tokenizer(",."); 673 - let map = parse_brackets(&tokens).unwrap(); 690 + let source = ",."; 691 + let tokens = tokenizer(source); 692 + let map = parse_brackets(&tokens, source).unwrap(); 674 693 let mut machine = VM::builder() 675 694 .tape(1) 676 695 .input_type(IOFormat::Raw) ··· 689 708 // overflow into another 690 709 #[test] 691 710 fn read_raw_discard() { 692 - let tokens = tokenizer(",>,<.>."); 693 - let map = parse_brackets(&tokens).unwrap(); 711 + let source = ",>,<.>."; 712 + let tokens = tokenizer(source); 713 + let map = parse_brackets(&tokens, source).unwrap(); 694 714 let mut machine = VM::builder() 695 715 .input_type(IOFormat::Raw) 696 716 .output_type(IOFormat::Raw)