From 8508f9e8a873a140561f5171f03c5c10666284c8 Mon Sep 17 00:00:00 2001
From: Sweetbread <risdeveau@lair.moe>
Date: Sun, 14 Jun 2026 03:25:10 +0300
Subject: [PATCH] test: add tests for RPN

---
 src/rpn.rs | 158 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 158 insertions(+)

diff --git a/src/rpn.rs b/src/rpn.rs
index f9fe92a..70f3edb 100644
--- a/src/rpn.rs
+++ b/src/rpn.rs
@@ -43,3 +43,161 @@ pub fn to_rpn(tokens: Vec<Token>) -> Vec<Token> {
 
   return out_buf;
 }
+
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::tokenizer::Token;
+
+  fn num(n: i32) -> Token { Token::Number(n) }
+  fn add() -> Token { Token::Addition }
+  fn sub() -> Token { Token::Substruction }
+  fn mul() -> Token { Token::Multiplication }
+  fn div() -> Token { Token::Division }
+  fn br_open() -> Token { Token::BracketOpen }
+  fn br_close() -> Token { Token::BracketClose }
+
+  #[test]
+  fn test_single_number() {
+    let input = vec![num(42)];
+    let expected = vec![num(42)];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_empty() {
+    let input = vec![];
+    let expected = vec![];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_addition() {
+    let input = vec![num(2), add(), num(3)];
+    let expected = vec![num(2), num(3), add()];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_priority() {
+    let input = vec![num(2), add(), num(3), mul(), num(4)];
+    let expected = vec![num(2), num(3), num(4), mul(), add()];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_left_associativity() {
+    let input = vec![num(1), sub(), num(2), sub(), num(3)];
+    let expected = vec![num(1), num(2), sub(), num(3), sub()];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_left_associativity_division() {
+    let input = vec![num(100), div(), num(5), div(), num(2)];
+    let expected = vec![num(100), num(5), div(), num(2), div()];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_brackets_basic() {
+    let input = vec![
+      br_open(), num(2), add(), num(3), br_close(), mul(), num(4)
+    ];
+    let expected = vec![num(2), num(3), add(), num(4), mul()];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_nested_brackets() {
+    let input = vec![
+      br_open(), num(2), add(), num(3), br_close(),
+      mul(),
+      br_open(), num(4), sub(), num(1), br_close()
+    ];
+    let expected = vec![
+      num(2), num(3), add(),
+      num(4), num(1), sub(),
+      mul()
+    ];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_deeply_nested() {
+    let input = vec![
+      br_open(), br_open(), num(1), add(), num(2), br_close(),
+      mul(),
+      br_open(), num(3), add(), num(4), br_close(),
+      br_close()
+    ];
+    let expected = vec![
+      num(1), num(2), add(),
+      num(3), num(4), add(),
+      mul()
+    ];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_complex_expression() {
+    let input = vec![
+      num(12), add(), num(34), mul(),
+      br_open(), num(56), sub(), num(78), br_close(),
+      div(), num(90)
+    ];
+    let expected = vec![
+      num(12), num(34), num(56), num(78), sub(), mul(), num(90), div(), add()
+    ];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_consecutive_operators() {
+    let input = vec![num(5), mul(), sub(), num(3)];
+    let expected_current = vec![num(5), num(3), mul(), sub()];
+    assert_eq!(to_rpn(input), expected_current);
+  }
+
+  #[test]
+  fn test_unary_minus() {
+    let input = vec![sub(), num(5)];
+    let expected = vec![num(5), sub()];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_only_operators() {
+    let input = vec![add(), mul(), sub()];
+    let expected = vec![sub(), mul(), add()];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_empty_brackets() {
+    let input = vec![br_open(), br_close()];
+    let expected: Vec<Token> = vec![];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_brackets_single_number() {
+    let input = vec![br_open(), num(42), br_close()];
+    let expected = vec![num(42)];
+    assert_eq!(to_rpn(input), expected);
+  }
+
+  #[test]
+  fn test_equal_priority_with_brackets() {
+    let input = vec![
+      num(1), add(),
+      br_open(), num(2), sub(), num(3), br_close(),
+      add(), num(4)
+    ];
+    let expected = vec![
+      num(1), num(2), num(3), sub(), add(), num(4), add()
+    ];
+    assert_eq!(to_rpn(input), expected);
+  }
+}