gbf @ 630532a84d44109e8543340defe0ee1faa958a36

A test/gbf_parser_test.gleam

@@ -0,0 +1,28 @@
+import gbf/lexer.{Position}
+import gbf/parser.{Block, Leaf, Node}
+import gbf/token.{DecrementByte, IncrementByte, IncrementPointer}
+import gleeunit/should
+
+pub fn should_parse_test() {
+  "+[->+]>"
+  |> lexer.new
+  |> lexer.lex
+  |> parser.parse
+  |> should.equal(
+    Ok(
+      Node(
+        Block(position: Position(0), children: [
+          Leaf(#(IncrementByte, Position(0))),
+          Node(
+            Block(position: Position(1), children: [
+              Leaf(#(DecrementByte, Position(2))),
+              Leaf(#(IncrementPointer, Position(3))),
+              Leaf(#(IncrementByte, Position(4))),
+            ]),
+          ),
+          Leaf(#(IncrementPointer, Position(6))),
+        ]),
+      ),
+    ),
+  )
+}

M test/gbf_test.gleam

@@ -1,5 +1,19 @@
+import gbf
+import gbf/vm
 import gleeunit
+import gleeunit/should
 
 pub fn main() -> Nil {
   gleeunit.main()
 }
+
+pub fn should_run_hello_world_test() {
+  let input =
+    "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++."
+
+  let assert Ok(bvm) = gbf.run(input)
+
+  bvm
+  |> vm.output
+  |> should.equal("Hello World!\n")
+}

A test/gbf_vm_test.gleam

@@ -0,0 +1,76 @@
+import char
+import gbf/vm.{type VirtualMachine}
+import gleam/result
+import gleeunit/should
+
+fn setup(input) -> VirtualMachine {
+  vm.new(input)
+}
+
+pub fn get_cell_test() {
+  let vm = setup([])
+
+  vm.get_cell(vm, 3)
+  |> should.equal(Ok(0))
+}
+
+pub fn get_cell_out_of_tape_test() {
+  let vm = setup([])
+
+  vm.get_cell(vm, vm.tape_size + 1)
+  |> should.equal(Error(vm.PointerRanOffTape))
+}
+
+pub fn set_cell_test() {
+  let vm = setup([])
+
+  vm.set_cell(vm, 2, 22)
+  |> should.be_ok
+}
+
+pub fn set_cell_errors_test() {
+  let vm = setup([])
+
+  vm.set_cell(vm, vm.tape_size + 1, 22)
+  |> should.be_error
+
+  vm.set_cell(vm, 2, vm.cell_size + 1)
+  |> should.be_error
+}
+
+pub fn set_pointer_test() {
+  let vm = setup([])
+
+  vm.set_pointer(vm, 2)
+  |> should.be_ok
+}
+
+pub fn output_byte_empty_test() {
+  let vm = setup([])
+
+  vm.output_byte(vm)
+  |> should.equal(Error(vm.InvalidChar(0)))
+}
+
+pub fn output_byte_test() {
+  let vm = setup([char.to_code("a")])
+  use vm <- result.try(vm.output_byte(vm))
+
+  should.equal(vm.output, "a")
+  Ok("")
+}
+
+pub fn input_byte_empty_test() {
+  let vm = setup([])
+
+  vm.input_byte(vm)
+  |> should.equal(Error(vm.EmptyInput))
+}
+
+pub fn input_byte_test() {
+  let vm = setup([char.to_code("a"), char.to_code("b")])
+  use vm <- result.try(vm.input_byte(vm))
+
+  should.equal(vm.input, [char.to_code("b")])
+  Ok("")
+}