Merge pull request #123 from myyrakle/test/#119

[#119] lexer 테스트코드 작성
myyrakle · Jul 15, 2024 · f095346 · f095346
2 parents 8ddca50 + c5c5804
commit f095346
Show file tree

Hide file tree

Showing 9 changed files with 577 additions and 1 deletion.
diff --git a/src/errors/execute_error.rs b/src/errors/execute_error.rs
@@ -6,6 +6,12 @@ pub struct ExecuteError {
     pub backtrace: std::backtrace::Backtrace,
 }
 
+impl PartialEq for ExecuteError {
+    fn eq(&self, other: &Self) -> bool {
+        self.message == other.message
+    }
+}
+
 impl ExecuteError {
     pub fn wrap<T: ToString>(message: T) -> RRDBError {
         RRDBError::ExecuteError(Self {

diff --git a/src/errors/into_error.rs b/src/errors/into_error.rs
@@ -6,6 +6,12 @@ pub struct IntoError {
     pub backtrace: std::backtrace::Backtrace,
 }
 
+impl PartialEq for IntoError {
+    fn eq(&self, other: &Self) -> bool {
+        self.message == other.message
+    }
+}
+
 impl IntoError {
     pub fn wrap<T: ToString>(message: T) -> RRDBError {
         RRDBError::IntoError(Self {

diff --git a/src/errors/lexing_error.rs b/src/errors/lexing_error.rs
@@ -6,6 +6,12 @@ pub struct LexingError {
     pub backtrace: std::backtrace::Backtrace,
 }
 
+impl PartialEq for LexingError {
+    fn eq(&self, other: &Self) -> bool {
+        self.message == other.message
+    }
+}
+
 impl LexingError {
     pub fn wrap<T: ToString>(message: T) -> RRDBError {
         RRDBError::LexingError(Self {

diff --git a/src/errors/mod.rs b/src/errors/mod.rs
@@ -6,7 +6,7 @@ pub mod predule;
 pub mod server_error;
 pub mod type_error;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum RRDBError {
     ExecuteError(execute_error::ExecuteError),
     IntoError(into_error::IntoError),

diff --git a/src/errors/parsing_error.rs b/src/errors/parsing_error.rs
@@ -6,6 +6,12 @@ pub struct ParsingError {
     pub backtrace: std::backtrace::Backtrace,
 }
 
+impl PartialEq for ParsingError {
+    fn eq(&self, other: &Self) -> bool {
+        self.message == other.message
+    }
+}
+
 impl ParsingError {
     pub fn wrap<T: ToString>(message: T) -> RRDBError {
         RRDBError::ParsingError(Self {

diff --git a/src/errors/server_error.rs b/src/errors/server_error.rs
@@ -4,6 +4,12 @@ pub struct ServerError {
     pub backtrace: std::backtrace::Backtrace,
 }
 
+impl PartialEq for ServerError {
+    fn eq(&self, other: &Self) -> bool {
+        self.message == other.message
+    }
+}
+
 impl ServerError {
     pub fn new<T: ToString>(message: T) -> Self {
         Self {

diff --git a/src/errors/type_error.rs b/src/errors/type_error.rs
@@ -6,6 +6,12 @@ pub struct TypeError {
     pub backtrace: std::backtrace::Backtrace,
 }
 
+impl PartialEq for TypeError {
+    fn eq(&self, other: &Self) -> bool {
+        self.message == other.message
+    }
+}
+
 impl TypeError {
     pub fn wrap<T: ToString>(message: T) -> RRDBError {
         RRDBError::TypeError(Self {

diff --git a/src/lexer/operator_token.rs b/src/lexer/operator_token.rs
@@ -72,3 +72,252 @@ 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;
+
+        struct TestCase {
+            name: String,
+            input: OperatorToken,
+            want_error: bool,
+            expected: BinaryOperator,
+        }
+
+        let test_cases = vec![
+            TestCase {
+                name: "연산자: +".to_owned(),
+                input: OperatorToken::Plus,
+                want_error: false,
+                expected: BinaryOperator::Add,
+            },
+            TestCase {
+                name: "연산자: -".to_owned(),
+                input: OperatorToken::Minus,
+                want_error: false,
+                expected: BinaryOperator::Sub,
+            },
+            TestCase {
+                name: "연산자: *".to_owned(),
+                input: OperatorToken::Asterisk,
+                want_error: false,
+                expected: BinaryOperator::Mul,
+            },
+            TestCase {
+                name: "연산자: /".to_owned(),
+                input: OperatorToken::Slash,
+                want_error: false,
+                expected: BinaryOperator::Div,
+            },
+            TestCase {
+                name: "연산자: <".to_owned(),
+                input: OperatorToken::Lt,
+                want_error: false,
+                expected: BinaryOperator::Lt,
+            },
+            TestCase {
+                name: "연산자: >".to_owned(),
+                input: OperatorToken::Gt,
+                want_error: false,
+                expected: BinaryOperator::Gt,
+            },
+            TestCase {
+                name: "연산자: <=".to_owned(),
+                input: OperatorToken::Lte,
+                want_error: false,
+                expected: BinaryOperator::Lte,
+            },
+            TestCase {
+                name: "연산자: >=".to_owned(),
+                input: OperatorToken::Gte,
+                want_error: false,
+                expected: BinaryOperator::Gte,
+            },
+            TestCase {
+                name: "연산자: =".to_owned(),
+                input: OperatorToken::Eq,
+                want_error: false,
+                expected: BinaryOperator::Eq,
+            },
+            TestCase {
+                name: "연산자: !=".to_owned(),
+                input: OperatorToken::Neq,
+                want_error: false,
+                expected: BinaryOperator::Neq,
+            },
+            TestCase {
+                name: "연산자: !".to_owned(),
+                input: OperatorToken::Not,
+                want_error: true,
+                expected: BinaryOperator::Neq,
+            },
+        ];
+
+        for t in test_cases {
+            let got = TryInto::<BinaryOperator>::try_into(t.input);
+
+            assert_eq!(
+                got.is_err(),
+                t.want_error,
+                "{}: want_error: {}, error: {:?}",
+                t.name,
+                t.want_error,
+                got.err()
+            );
+
+            if let Ok(tokens) = got {
+                assert_eq!(tokens, t.expected, "TC: {}", t.name);
+            }
+        }
+    }
+
+    #[test]
+    fn test_operator_token_try_into_unary_operator() {
+        use super::{OperatorToken, UnaryOperator};
+        use std::convert::TryInto;
+
+        struct TestCase {
+            name: String,
+            input: OperatorToken,
+            want_error: bool,
+            expected: UnaryOperator,
+        }
+
+        let test_cases = vec![
+            TestCase {
+                name: "연산자: +".to_owned(),
+                input: OperatorToken::Plus,
+                want_error: false,
+                expected: UnaryOperator::Pos,
+            },
+            TestCase {
+                name: "연산자: -".to_owned(),
+                input: OperatorToken::Minus,
+                want_error: false,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: *".to_owned(),
+                input: OperatorToken::Asterisk,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: /".to_owned(),
+                input: OperatorToken::Slash,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: <".to_owned(),
+                input: OperatorToken::Lt,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: >".to_owned(),
+                input: OperatorToken::Gt,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: <=".to_owned(),
+                input: OperatorToken::Lte,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: >=".to_owned(),
+                input: OperatorToken::Gte,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: =".to_owned(),
+                input: OperatorToken::Eq,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: !=".to_owned(),
+                input: OperatorToken::Neq,
+                want_error: true,
+                expected: UnaryOperator::Neg,
+            },
+            TestCase {
+                name: "연산자: !".to_owned(),
+                input: OperatorToken::Not,
+                want_error: false,
+                expected: UnaryOperator::Not,
+            },
+        ];
+
+        for t in test_cases {
+            let got = TryInto::<UnaryOperator>::try_into(t.input);
+
+            assert_eq!(
+                got.is_err(),
+                t.want_error,
+                "{}: want_error: {}, error: {:?}",
+                t.name,
+                t.want_error,
+                got.err()
+            );
+
+            if let Ok(tokens) = got {
+                assert_eq!(tokens, t.expected, "TC: {}", t.name);
+            }
+        }
+    }
+}