Compare the speed of various BF implementations in Rust.

brainfuck-test.rs

#![feature(test)]

extern crate test;
extern crate brainfuck;
extern crate bf;

use test::Bencher;

const HELLO_WORLD: &'static str = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]
    >++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.";
const NUMWRAP: &'static str = ">>>>+>+++>+++>>>>>+++[
  >,+>++++[>++++<-]>[<<[-[->]]>[<]>-]<<[
    >+>+>>+>+[<<<<]<+>>[+<]<[>]>+[[>>>]>>+[<<<<]>-]+<+>>>-[
      <<+[>]>>+<<<+<+<--------[
        <<-<<+[>]>+<<-<<-[
          <<<+<-[>>]<-<-<<<-<----[
            <<<->>>>+<-[
              <<<+[>]>+<<+<-<-[
                <<+<-<+[>>]<+<<<<+<-[
                  <<-[>]>>-<<<-<-<-[
                    <<<+<-[>>]<+<<<+<+<-[
                      <<<<+[>]<-<<-[
                        <<+[>]>>-<<<<-<-[
                          >>>>>+<-<<<+<-[
                            >>+<<-[
                              <<-<-[>]>+<<-<-<-[
                                <<+<+[>]<+<+<-[
                                  >>-<-<-[
                                    <<-[>]<+<++++[<-------->-]++<[
                                      <<+[>]>>-<-<<<<-[
                                        <<-<<->>>>-[
                                          <<<<+[>]>+<<<<-[
                                            <<+<<-[>>]<+<<<<<-[
                                              >>>>-<<<-<-
  ]]]]]]]]]]]]]]]]]]]]]]>[>[[[<<<<]>+>>[>>>>>]<-]<]>>>+>>>>>>>+>]<
]<[-]<<<<<<<++<+++<+++[
  [>]>>>>>>++++++++[<<++++>++++++>-]<-<<[-[<+>>.<-]]<<<<[
    -[-[>+<-]>]>>>>>[.[>]]<<[<+>-]>>>[<<++[<+>--]>>-]
    <<[->+<[<++>-]]<<<[<+>-]<<<<
  ]>>+>>>--[<+>---]<.>>[[-]<<]<
]";

#[test]
fn bf_runs() {
    use bf::traits::Interpretable;
    let program = bf::ast::parse_program(NUMWRAP.as_bytes()).unwrap();
    program.interpret_memory(None, b"1499\n").unwrap();
}

#[test]
fn brainfuck_runs() {
    use brainfuck::program::Program;
    use brainfuck::Interpreter;
    use brainfuck::tape::VecTape;

    let mut reader = "1499\n".as_bytes();
    let mut writer = Vec::<u8>::new();
    let program = Program::parse(NUMWRAP).unwrap();
    let mut interpretor = Interpreter::<VecTape>::new(
        program,
        &mut reader,
        &mut writer);
    interpretor.run().unwrap();
}

#[test]
fn bf_works() {
    use bf::traits::Interpretable;
    let program = bf::ast::parse_program(HELLO_WORLD.as_bytes()).unwrap();
    match program.interpret_memory(None, b"") {
        Ok(b) => assert_eq!("Hello World!\n", String::from_utf8(b).unwrap()),
        Err(_) => assert!(false),
    }
}

#[test]
fn brainfuck_works() {
    use brainfuck::program::Program;
    use brainfuck::Interpreter;
    use brainfuck::tape::VecTape;

    let mut reader = "".as_bytes();
    let mut writer = Vec::<u8>::new();
    {
        let program = Program::parse(HELLO_WORLD).unwrap();
        let mut interpretor = Interpreter::<VecTape>::new(
            program,
            &mut reader,
            &mut writer);
        interpretor.run().unwrap();
    }

    assert_eq!("Hello World!\n", String::from_utf8(writer).unwrap());
}

#[bench]
fn bf_speed(b: &mut Bencher) {
    use bf::traits::Interpretable;

    b.iter(|| {
        let program = bf::ast::parse_program(HELLO_WORLD.as_bytes()).unwrap();
        program.interpret_memory(None, b"").unwrap()
    });
}

#[bench]
fn brainfuck(b: &mut Bencher) {
    use brainfuck::program::Program;
    use brainfuck::Interpreter;
    use brainfuck::tape::VecTape;

    b.iter(|| {
        let mut reader = "".as_bytes();
        let mut writer = Vec::<u8>::new();
        let program = Program::parse(HELLO_WORLD).unwrap();
        let mut interpretor = Interpreter::<VecTape>::new(
            program,
            &mut reader,
            &mut writer);
        interpretor.run().unwrap();
    });
}