From d0ec5243d3770cdea12d12ba9351d6ffccd82f96 Mon Sep 17 00:00:00 2001
From: myyrakle <sssang97@naver.com>
Date: Sun, 14 Jul 2024 20:07:12 +0900
Subject: [PATCH] =?UTF-8?q?[#119]=20OperatorToken=20=ED=85=8C=EC=8A=A4?=
 =?UTF-8?q?=ED=8A=B8=EC=BD=94=EB=93=9C=20=EC=9E=91=EC=84=B1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/lexer/operator_token.rs | 75 +++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/src/lexer/operator_token.rs b/src/lexer/operator_token.rs
index 61d1c4ec..3d6293c0 100644
--- a/src/lexer/operator_token.rs
+++ b/src/lexer/operator_token.rs
@@ -72,3 +72,78 @@ impl TryInto<UnaryOperator> for OperatorToken {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_operator_token_is_binary_operator() {
+        use super::OperatorToken;
+
+        let test_cases = vec![
+            (OperatorToken::Plus, true),
+            (OperatorToken::Minus, true),
+            (OperatorToken::Asterisk, true),
+            (OperatorToken::Slash, true),
+            (OperatorToken::Lt, true),
+            (OperatorToken::Gt, true),
+            (OperatorToken::Lte, true),
+            (OperatorToken::Gte, true),
+            (OperatorToken::Eq, true),
+            (OperatorToken::Neq, true),
+            (OperatorToken::Not, false),
+        ];
+
+        for (input, expected) in test_cases {
+            let got = input.is_binary_operator();
+            assert_eq!(got, expected);
+        }
+    }
+
+    #[test]
+    fn test_operator_token_is_unary_operator() {
+        use super::OperatorToken;
+
+        let test_cases = vec![
+            (OperatorToken::Plus, true),
+            (OperatorToken::Minus, true),
+            (OperatorToken::Asterisk, false),
+            (OperatorToken::Slash, false),
+            (OperatorToken::Lt, false),
+            (OperatorToken::Gt, false),
+            (OperatorToken::Lte, false),
+            (OperatorToken::Gte, false),
+            (OperatorToken::Eq, false),
+            (OperatorToken::Neq, false),
+            (OperatorToken::Not, true),
+        ];
+
+        for (input, expected) in test_cases {
+            let got = input.is_unary_operator();
+            assert_eq!(got, expected);
+        }
+    }
+
+    #[test]
+    fn test_operator_token_try_into_binary_operator() {
+        use super::{BinaryOperator, OperatorToken};
+        use std::convert::TryInto;
+
+        let test_cases = vec![
+            (OperatorToken::Plus, BinaryOperator::Add),
+            (OperatorToken::Minus, BinaryOperator::Sub),
+            (OperatorToken::Asterisk, BinaryOperator::Mul),
+            (OperatorToken::Slash, BinaryOperator::Div),
+            (OperatorToken::Lt, BinaryOperator::Lt),
+            (OperatorToken::Gt, BinaryOperator::Gt),
+            (OperatorToken::Lte, BinaryOperator::Lte),
+            (OperatorToken::Gte, BinaryOperator::Gte),
+            (OperatorToken::Eq, BinaryOperator::Eq),
+            (OperatorToken::Neq, BinaryOperator::Neq),
+        ];
+
+        for (input, expected) in test_cases {
+            let got: BinaryOperator = input.try_into().unwrap();
+            assert_eq!(got, expected);
+        }
+    }
+}