Updating code and tests

Author: davassi

src/lib.rs

@@ -112,3 +112,4 @@ pub mod rpn_resolver;
 pub mod session;
 /// Token
 pub mod token;
+

src/rpn_resolver.rs

@@ -193,12 +193,6 @@ impl RpnResolver<'_> {
                     }
                 },
 
-                /* If the token is an operator, op1, then:
-                   while there is an operator, op2, at the top of the stack, and op1 is left-associative 
-                   and its precedence is less than or equal to that of op2, 
-                   or op1 is right-associative and its precedence is less than that of op2:
-                      pop op2 off the stack, onto the output list;
-                    push op1 on the stack.*/
                 Token::Operator(_op) => {
                     let op1: Token<'_> = t.clone();
 
@@ -239,23 +233,22 @@ impl RpnResolver<'_> {
         /* After all tokens are read, pop remaining operators from the stack and add them to the list. */
         operators_stack.reverse();
         operators_stack.iter().for_each(|t| postfix_stack.push_back(t.clone()));
-        //postfix_stack.pop_front()
-        //postfix_stack.extend(operators_stack.iter());
-
+        
         debug!(
-            "Inspecting... EOF - OUT {} - OP - {}", DisplayThisDeque(&postfix_stack), DisplayThatVec(&operators_stack)
+            "DEBUG: EOF - OUT {} - OP - {}", DisplayThisDeque(&postfix_stack), DisplayThatVec(&operators_stack)
         );
 
         (postfix_stack, local_heap)
     }
 
     fn factorial_helper(n: BigInt) -> BigInt {
-        if n == Zero::zero(){
-            One::one()
-        } else {
-            n.checked_mul(&RpnResolver::factorial_helper(n.checked_sub(&One::one()).expect("It should not happen")))
-                .expect("It should not happen.")
+        if n == BigInt::zero() {
+            return BigInt::one();
         }
+    
+        let previous = n.checked_sub(&BigInt::one()).expect("Subtraction underflow");
+        let sub_result = RpnResolver::factorial_helper(previous);
+        n.checked_mul(&sub_result).expect("Multiplication overflow")
     }
 }
 
@@ -297,4 +290,23 @@ mod tests {
             b
         );
     }
+
+    #[test]
+    fn test_factorial() {
+        assert_eq!(RpnResolver::factorial_helper(BigInt::from(5)), BigInt::from(120));
+    }
+
+    #[test]
+    fn test_resolve() {
+        let mut resolver = RpnResolver {
+            rpn_expr: VecDeque::from(vec![
+                Token::Operand(Number::NaturalNumber(BigInt::from(1u8))),
+                Token::Operand(Number::NaturalNumber(BigInt::from(2u8))),
+                Token::Operator(Operator::Add),
+            ]),
+            local_heap: Rc::new(RefCell::new(HashMap::new())),
+        };
+        assert_eq!(resolver.resolve().unwrap(), Number::NaturalNumber(BigInt::from(3u8)));
+    }
+
 }

src/session.rs

@@ -77,3 +77,25 @@ impl Session {
             .insert(key.to_string(), Number::DecimalNumber(value));
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::token::Number;
+
+    #[test]
+    fn test_session() {
+        let session = Session::init();
+        let mut resolver: RpnResolver = session.process("1+2*3/(4-5)");
+        assert_eq!(resolver.resolve().unwrap(), Number::DecimalNumber(-5.0));
+    }
+
+    #[test]
+    fn test_session_set() {
+        let session = Session::init();
+        session.set("x", 4);
+        let mut resolver: RpnResolver = session.process("x+2*3/(4-5)");
+        assert_eq!(resolver.resolve().unwrap(), Number::DecimalNumber(-2.0));
+    }
+}

src/token.rs

@@ -502,4 +502,36 @@ mod tests {
         );
         assert_eq!(Token::tokenize("("), Some(Token::Bracket(Bracket::Open)));
     }
+
+    #[test]
+    fn test_operator_priority() {
+        assert_eq!(
+            Token::operator_priority(Token::Operator(Operator::Add)),
+            (1, Associate::LeftAssociative)
+        );
+        assert_eq!(
+            Token::operator_priority(Token::Operator(Operator::Sub)),
+            (1, Associate::LeftAssociative)
+        );
+        assert_eq!(
+            Token::operator_priority(Token::Operator(Operator::Mul)),
+            (2, Associate::LeftAssociative)
+        );
+        assert_eq!(
+            Token::operator_priority(Token::Operator(Operator::Div)),
+            (2, Associate::LeftAssociative)
+        );
+        assert_eq!(
+            Token::operator_priority(Token::Operator(Operator::Pow)),
+            (3, Associate::RightAssociative)
+        );
+        assert_eq!(
+            Token::operator_priority(Token::Operator(Operator::Une)),
+            (4, Associate::RightAssociative)
+        );
+        assert_eq!(
+            Token::operator_priority(Token::Operator(Operator::Fac)),
+            (5, Associate::LeftAssociative)
+        );
+    }
 }

tests/integration_tests.rs

@@ -22,6 +22,10 @@ fn test_expressions() {
         "pi * 4. + 2^pi",
         Number::DecimalNumber(std::f64::consts::PI * 4.0 + 2.0f64.powf(std::f64::consts::PI))
     );
+    resolve!(
+        "2^3 * 4 + 5^2",
+        Number::NaturalNumber(BigInt::from(8 * 4 + 25))
+    );
     resolve!(
         "sin(pi / 4) + cos(pi / 4)",
         Number::DecimalNumber(1.414213562373095)
@@ -78,6 +82,10 @@ fn test_expressions() {
         )
     );
     resolve!("((10 + 5) - 3 * ( 9 / 3 )) + 2", Number::DecimalNumber(8.0));
+    resolve!(
+        "2^3^2 - 3^3",
+        Number::NaturalNumber(BigInt::from(512 - 27))
+    );
 }
 
 #[test]
@@ -111,3 +119,11 @@ fn test_sharing_session() {
         assert!(b == 3265920i64);
     }
 }
+
+#[test]
+fn test_session_set() {
+    let session = Session::init();
+    session.set("x", 4);
+    let mut resolver: RpnResolver = session.process("x+2*3/(4-5)");
+    assert_eq!(resolver.resolve().unwrap(), Number::DecimalNumber(-2.0));
+}