test(assembler): Add tests

1 files changed, 144 insertions, 0 deletions

diff --git a/assembler/src/lexer/mod.rs b/assembler/src/lexer/mod.rs
index c8c8c83..45de90f 100644
--- a/assembler/src/lexer/mod.rs
+++ b/assembler/src/lexer/mod.rs
@@ -104,3 +104,147 @@ pub fn split(mut line: String) -> Vec<Token> {
     }
     res
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn splits_label() {
+        let res = split("label1:".to_string());
+        assert_eq!(res.len(), 1);
+        assert!(matches!(res[0], Token::Label(_)));
+        if let Token::Label(name) = &res[0] {
+            assert_eq!(name, "label1");
+        }
+    }
+
+    #[test]
+    fn splits_lowercase_instruction_no_args() {
+        let res = split("instr".to_string());
+        assert_eq!(res.len(), 1);
+        assert!(matches!(res[0], Token::Operator(_)));
+        if let Token::Operator(name) = &res[0] {
+            assert_eq!(name, "instr");
+        }
+    }
+
+    #[test]
+    fn splits_pascal_instruction_no_args() {
+        let res = split("Instr".to_string());
+        assert_eq!(res.len(), 1);
+        assert!(matches!(res[0], Token::Operator(_)));
+        if let Token::Operator(name) = &res[0] {
+            assert_eq!(name, "Instr");
+        }
+    }
+
+    #[test]
+    fn splits_uppercase_instruction_no_args() {
+        let res = split("INSTR".to_string());
+        assert_eq!(res.len(), 1);
+        assert!(matches!(res[0], Token::Operator(_)));
+        if let Token::Operator(name) = &res[0] {
+            assert_eq!(name, "INSTR");
+        }
+    }
+
+    #[test]
+    fn splits_instruction_symbol_arg() {
+        let res = split("instr x".to_string());
+        assert_eq!(res.len(), 2);
+
+        assert!(matches!(res[0], Token::Operator(_)));
+        if let Token::Operator(name) = &res[0] {
+            assert_eq!(name, "instr");
+        }
+
+        assert!(matches!(res[1], Token::Symbol(_)));
+        if let Token::Symbol(name) = &res[1] {
+            assert_eq!(name, "x");
+        }
+    }
+
+    #[test]
+    fn splits_instruction_two_symbol_arg() {
+        let res = split("instr x, y".to_string());
+        assert_eq!(res.len(), 3);
+
+        assert!(matches!(res[0], Token::Operator(_)));
+        if let Token::Operator(name) = &res[0] {
+            assert_eq!(name, "instr");
+        }
+
+        assert!(matches!(res[1], Token::Symbol(_)));
+        if let Token::Symbol(name) = &res[1] {
+            assert_eq!(name, "x");
+        }
+
+        assert!(matches!(res[2], Token::Symbol(_)));
+        if let Token::Symbol(name) = &res[2] {
+            assert_eq!(name, "y");
+        }
+    }
+
+    #[test]
+    fn splits_instruction_two_num_arg() {
+        let res = split("instr 819, 1".to_string());
+        assert_eq!(res.len(), 3);
+
+        assert!(matches!(res[0], Token::Operator(_)));
+        if let Token::Operator(name) = &res[0] {
+            assert_eq!(name, "instr");
+        }
+
+        assert!(matches!(res[1], Token::Number(_)));
+        if let Token::Number(value) = &res[1] {
+            assert_eq!(value, &819);
+        }
+
+        assert!(matches!(res[2], Token::Number(_)));
+        if let Token::Number(value) = &res[2] {
+            assert_eq!(value, &1);
+        }
+    }
+
+    #[test]
+    fn splits_definition() {
+        let res = split("somevar = 61".to_string());
+        assert_eq!(res.len(), 2);
+
+        assert!(matches!(res[0], Token::SymbolDef(_)));
+        if let Token::SymbolDef(name) = &res[0] {
+            assert_eq!(name, "somevar");
+        }
+    }
+
+    #[test]
+    fn splits_number() {
+        let res = split("561".to_string());
+        assert_eq!(res.len(), 1);
+        assert!(matches!(res[0], Token::Number(_)));
+        if let Token::Number(value) = &res[0] {
+            assert_eq!(value, &561);
+        }
+    }
+
+    #[test]
+    fn splits_address() {
+        let res = split("%561".to_string());
+        assert_eq!(res.len(), 1);
+        assert!(matches!(res[0], Token::Address(_)));
+        if let Token::Address(value) = &res[0] {
+            assert_eq!(value, &561);
+        }
+    }
+
+    #[test]
+    fn splits_string() {
+        let res = split("\"Hello World!\"".to_string());
+        assert_eq!(res.len(), 1);
+        assert!(matches!(res[0], Token::String(_)));
+        if let Token::String(value) = &res[0] {
+            assert_eq!(value, "Hello World!");
+        }
+    }
+}