From 8b65d8b6cf8ad44e7cae58bfda883567b8cc32fc Mon Sep 17 00:00:00 2001
From: Syndamia <kamen@syndamia.com>
Date: Sat, 15 Feb 2025 11:01:08 +0200
Subject: test(assembler): Add tests

---
 assembler/src/lexer/mod.rs | 144 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 144 insertions(+)

(limited to 'assembler/src/lexer')

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!");
+        }
+    }
+}
-- 
cgit v1.3.1-24-g813c