Merge pull request #2 from gdziadkiewicz/Add_error_handling_and_more_tests

Add better error handling and more tests

Author: gdziadkiewicz

README.md

@@ -7,5 +7,8 @@ Inspired by https://www.codewars.com/kata/526156943dfe7ce06200063e
 ### TODO:
 * [x] Add CLI
 * [x] Add handling of whitespace
-* [ ] Add better error handling to the interpreted
-* [x] Add CI 
+* [x] Add better error handling to the interpreter
+* [x] Add CI
+* [ ] Rewrite tests with Results to get rid of unwrapping
+* [ ] Rewrite add, sub and mul test as property tests
+* [ ] Try to use b"" to make the tests more readable

build.ps1

@@ -0,0 +1,17 @@
+cargo test --all-features
+if ($LASTEXITCODE -ne 0) {
+    Write-Error "Cargo test failed with exit code $LASTEXITCODE"
+    exit $LASTEXITCODE
+}
+
+cargo fmt --all -- --check
+if ($LASTEXITCODE -ne 0) {
+    Write-Error "Cargo fmt failed with exit code $LASTEXITCODE"
+    exit $LASTEXITCODE
+}
+
+cargo clippy --all --all-features --tests -- -D warnings
+if ($LASTEXITCODE -ne 0) {
+    Write-Error "Cargo clippy failed with exit code $LASTEXITCODE"
+    exit $LASTEXITCODE
+}

src/lib.rs

@@ -1,4 +1,29 @@
-pub fn brain_luck(code: &str, input: Vec<u8>) -> Vec<u8> {
+//create error type for my lib and use it for brain_luck function
+use std::error::Error;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum BrainLuckError {
+    UnexpectedCharInCode(char),
+    UnexpectedEndOfInput,
+    UnbalancedBrackets,
+}
+
+impl std::fmt::Display for BrainLuckError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let message = match self {
+            BrainLuckError::UnexpectedCharInCode(c) => {
+                format!("unexpected char {} occured in code.", c)
+            }
+            BrainLuckError::UnexpectedEndOfInput => String::from("unexpected end of input."),
+            BrainLuckError::UnbalancedBrackets => String::from("unbalanced brackets."),
+        };
+        f.write_str(&message)
+    }
+}
+
+impl Error for BrainLuckError {}
+
+pub fn brain_luck(code: &str, input: Vec<u8>) -> Result<Vec<u8>, BrainLuckError> {
     let mut output = Vec::new();
     let mut input = input.iter();
     let mut memory = vec![0u8; 1000];
@@ -8,54 +33,29 @@ pub fn brain_luck(code: &str, input: Vec<u8>) -> Vec<u8> {
     let insts = code.chars().collect::<Vec<_>>();
     while let Some(c) = insts.get(ins_ptr) {
         match c {
-            '>' => {
-                mem_ptr += 1;
-                ins_ptr += 1;
-            }
-            '<' => {
-                mem_ptr -= 1;
-                ins_ptr += 1;
-            }
-            '+' => {
-                memory[mem_ptr] = memory[mem_ptr].wrapping_add(1);
-                ins_ptr += 1;
-            }
-            '-' => {
-                memory[mem_ptr] = memory[mem_ptr].wrapping_sub(1);
-                ins_ptr += 1;
-            }
-            '.' => {
-                output.push(memory[mem_ptr]);
-                ins_ptr += 1;
-            }
-            ',' => {
-                let b = input.next().unwrap();
-                memory[mem_ptr] = *b;
-                ins_ptr += 1;
-            }
+            '>' => mem_ptr += 1,
+            '<' => mem_ptr -= 1,
+            //TODO: add handling for mem_ptr going out of bounds (or accessing memory outside of bounds)
+            '+' => memory[mem_ptr] = memory[mem_ptr].wrapping_add(1),
+            '-' => memory[mem_ptr] = memory[mem_ptr].wrapping_sub(1),
+            '.' => output.push(memory[mem_ptr]),
+            ',' => memory[mem_ptr] = *input.next().ok_or(BrainLuckError::UnexpectedEndOfInput)?,
             '[' => {
-                let b = memory[mem_ptr];
-                if b == 0 {
-                    //jump to next after closing bracket
-                    ins_ptr = after_matching_closing_bracket(&insts, ins_ptr, Bracket::LBracket);
-                } else {
-                    ins_ptr += 1;
+                if memory[mem_ptr] == 0 {
+                    ins_ptr = matching_closing_bracket_ptr(&insts, ins_ptr, Bracket::LBracket)?;
                 }
             }
             ']' => {
-                let b = memory[mem_ptr];
-                if b != 0 {
-                    //jump to previous after closing bracket
-                    ins_ptr = after_matching_closing_bracket(&insts, ins_ptr, Bracket::RBracket);
-                } else {
-                    ins_ptr += 1;
+                if memory[mem_ptr] != 0 {
+                    ins_ptr = matching_closing_bracket_ptr(&insts, ins_ptr, Bracket::RBracket)?;
                 }
             }
-            c if c.is_whitespace() => ins_ptr += 1,
-            unexpected_char => panic!("Unexpected char {} occured in code.", unexpected_char),
+            c if c.is_whitespace() => (),
+            unexpected_char => return Err(BrainLuckError::UnexpectedCharInCode(*unexpected_char)),
         }
+        ins_ptr += 1;
     }
-    output
+    Ok(output)
 }
 
 enum Bracket {
@@ -66,14 +66,18 @@ enum Bracket {
 macro_rules! add {
     ($u:ident,$s:ident) => {
         if $s < 0 {
-            $u - (-$s) as usize
+            $u.checked_sub((-$s) as usize)
         } else {
-            $u + $s as usize
+            Some($u + $s as usize)
         }
     };
 }
 
-fn after_matching_closing_bracket(insts: &[char], ins_ptr: usize, b: Bracket) -> usize {
+fn matching_closing_bracket_ptr(
+    insts: &[char],
+    ins_ptr: usize,
+    b: Bracket,
+) -> Result<usize, BrainLuckError> {
     let direction = match b {
         Bracket::LBracket => 1,
         Bracket::RBracket => -1,
@@ -84,18 +88,22 @@ fn after_matching_closing_bracket(insts: &[char], ins_ptr: usize, b: Bracket) ->
     loop {
         let c = insts.get(ptr);
         match c {
-            None => panic!("Unbalanced brackets(EOF)!"),
+            None => return Err(BrainLuckError::UnbalancedBrackets),
             Some('[') => counter += direction,
             Some(']') => counter -= direction,
             Some(_) => (),
         }
         if counter < 0 {
-            panic!("Unbalanced brackets!")
+            return Err(BrainLuckError::UnbalancedBrackets);
         }
         if counter == 0 {
-            return ptr;
+            return Ok(ptr);
         }
-        ptr = add!(ptr, direction);
+        ptr = match add!(ptr, direction) {
+            Some(p) => p,
+            None if direction == -1 => return Err(BrainLuckError::UnbalancedBrackets),
+            None => unreachable!(),
+        };
     }
 }
 
@@ -108,7 +116,7 @@ mod tests {
     fn echo_until_byte_255_encountered() {
         // Echo until byte 255 encountered
         assert!(
-            String::from_utf8(brain_luck(",+[-.,+]", ez_vec("Codewars", 255))).unwrap()
+            String::from_utf8(brain_luck(",+[-.,+]", ez_vec("Codewars", 255)).unwrap()).unwrap()
                 == "Codewars"
         );
     }
@@ -117,14 +125,84 @@ mod tests {
     fn echo_until_byte_0_encountered() {
         // Echo until byte 0 encountered
         assert!(
-            String::from_utf8(brain_luck(",[.[-],]", ez_vec("Codewars", 0))).unwrap() == "Codewars"
+            String::from_utf8(brain_luck(",[.[-],]", ez_vec("Codewars", 0)).unwrap()).unwrap()
+                == "Codewars"
         );
     }
 
     #[test]
     fn multiply_two_numbers() {
         // Multiply two numbers
-        assert!(brain_luck(",>,<[>[->+>+<<]>>[-<<+>>]<<<-]>>.", vec![8, 9]) == vec![72]);
+        assert!(brain_luck(",>,<[>[->+>+<<]>>[-<<+>>]<<<-]>>.", vec![8, 9]).unwrap() == vec![72]);
+    }
+
+    #[test]
+    fn unexpected_char_in_code() {
+        // Unexpected character in code
+        assert!(matches!(
+            brain_luck(",[.[-]a,]", ez_vec("Hello", 0)),
+            Err(BrainLuckError::UnexpectedCharInCode('a'))
+        ));
+    }
+
+    #[test]
+    fn unbalanced_brackets() {
+        // Unbalanced brackets
+        assert!(
+            brain_luck("[.[-],", ez_vec("Hello", 0)) == Err(BrainLuckError::UnbalancedBrackets)
+        );
+    }
+
+    #[test]
+    fn unexpected_end_of_input() {
+        // Unexpected end of input
+        assert!(matches!(
+            brain_luck(",[.[-],]", vec![72, 101, 108, 108]),
+            Err(BrainLuckError::UnexpectedEndOfInput)
+        ));
+    }
+
+    #[test]
+    fn add_two_numbers() {
+        // Add two numbers
+        assert!(brain_luck(",>,<[->+<]>.", vec![5, 10]).unwrap() == vec![15]);
+    }
+
+    #[test]
+    fn subtract_two_numbers() {
+        // Subtract two numbers
+        assert!(brain_luck(">,>,[<[->]<]>>[[<+>-]>>]<<<.", vec![10, 5]).unwrap() == vec![5]);
+    }
+
+    #[test]
+    fn matching_closing_bracket_ptr_balanced() {
+        // Balanced brackets
+        let code = "++[--[++]]";
+        let insts = code.chars().collect::<Vec<_>>();
+        assert!(matching_closing_bracket_ptr(&insts, 2, Bracket::LBracket).unwrap() == 9);
+        assert!(matching_closing_bracket_ptr(&insts, 9, Bracket::RBracket).unwrap() == 2);
+    }
+
+    #[test]
+    fn matching_closing_bracket_ptr_unbalanced_left() {
+        // Unbalanced brackets (left)
+        let code = "++[--[++]";
+        let insts = code.chars().collect::<Vec<_>>();
+        assert!(matches!(
+            matching_closing_bracket_ptr(&insts, 2, Bracket::LBracket),
+            Err(BrainLuckError::UnbalancedBrackets)
+        ));
+    }
+
+    #[test]
+    fn matching_closing_bracket_ptr_unbalanced_right() {
+        // Unbalanced brackets (right)
+        let code = "++[--[++]]]";
+        let insts = code.chars().collect::<Vec<_>>();
+        assert!(matches!(
+            matching_closing_bracket_ptr(&insts, 10, Bracket::RBracket),
+            Err(BrainLuckError::UnbalancedBrackets)
+        ));
     }
 
     // Takes a static string and a terminating byte and returns an owned Vec<u8> for convenience

src/main.rs

@@ -21,6 +21,6 @@ fn main() -> Result<(), Box<dyn Error>> {
     let code = fs::read_to_string(&args.code)?;
     let input = args.input.as_ref().map(fs::read).unwrap_or(Ok(vec![]))?;
     let output = brain_luck(&code, input);
-    println!("{}", String::from_utf8(output)?);
+    println!("{}", String::from_utf8(output?)?);
     Ok(())
 }