added major test case

Author: martcpp

src/lexericals/lexer.rs

@@ -59,11 +59,34 @@ impl Lexer {
                     Token::new(Tokenkind::Bang, "!".to_string())
                 }
             }
+            '|' => {
+                self.read_token(); // Read the next character to check for '||'
+                if self.ch == '|' {
+                    Token::new(Tokenkind::OR, "||".to_string())
+                } else {
+                    Token::new(Tokenkind::Illegal, "|".to_string())
+                }
+            },
             '*' => Token::new(Tokenkind::Asterisk, self.ch.to_string()),
             '/' => Token::new(Tokenkind::Slash, self.ch.to_string()),
             '%' => Token::new(Tokenkind::Pencentage, self.ch.to_string()),
-            '<' => Token::new(Tokenkind::Lthan, self.ch.to_string()),
-            '>' => Token::new(Tokenkind::Gthan, self.ch.to_string()),
+            '<' => {
+                self.read_token(); // Read the next character to check for '<='
+                if self.ch == '=' {
+                    Token::new(Tokenkind::Lthanoreq, "<=".to_string())
+                } else {
+                    Token::new(Tokenkind::Lthan, "<".to_string())
+                }
+              
+            },
+            '>' =>{
+                self.read_token(); // Read the next character to check for '>='
+                if self.ch == '=' {
+                    Token::new(Tokenkind::Gthanoreq, ">=".to_string())
+                } else {
+                    Token::new(Tokenkind::Gthan, ">".to_string())
+                }
+            }, 
             '&' => {
                 self.read_token(); // Read the next character to check for '&&'
                 if self.ch == '&' {
@@ -215,4 +238,122 @@ mod test {
             ); // Move to the next character
         }
     }
+    #[test]
+    fn test_skip_whitespace() {
+        let input = "              let five = 5; \n let ten = 10;";
+        let mut lexer = Lexer::new(input);
+        let token1 = lexer.next_token();
+        assert_eq!(token1.kind, Tokenkind::Let);
+        assert_eq!(token1.literal, "let");
+    }
+
+    #[test]
+    fn test_read_number() {
+        let input = "12345 67890 12.34 56.78";
+        let mut lexer = Lexer::new(input);
+        let token1 = lexer.next_token();
+        assert_eq!(token1.kind, Tokenkind::Int);
+        assert_eq!(token1.literal, "12345");   
+    }
+    #[test]
+    fn test_read_float() {
+        let input = "0.34 56.78";
+        let mut lexer = Lexer::new(input);
+        let token1 = lexer.next_token();
+        assert_eq!(token1.kind, Tokenkind::Float);
+        assert_eq!(token1.literal, "0.34");
+
+        let token2 = lexer.next_token();
+        assert_eq!(token2.kind, Tokenkind::Float);
+        assert_eq!(token2.literal, "56.78");
+    }
+    #[test]
+    fn test_read_keywords() {
+        let input = "let fn if else return";
+        let mut lexer = Lexer::new(input);
+        let token1 = lexer.next_token();
+        assert_eq!(token1.kind, Tokenkind::Let);
+        assert_eq!(token1.literal, "let");
+
+        let token2 = lexer.next_token();
+        assert_eq!(token2.kind, Tokenkind::Function);
+        assert_eq!(token2.literal, "fn");
+
+        let token3 = lexer.next_token();
+        assert_eq!(token3.kind, Tokenkind::If);
+        assert_eq!(token3.literal, "if");
+
+        let token4 = lexer.next_token();
+        assert_eq!(token4.kind, Tokenkind::Else);
+        assert_eq!(token4.literal, "else");
+
+        let token5 = lexer.next_token();
+        assert_eq!(token5.kind, Tokenkind::Return);
+        assert_eq!(token5.literal, "return");
+
+    }
+    #[test]
+    fn test_read_identifiers() {
+        let input = "variable_name anotherVariable _privateVar";
+        let mut lexer = Lexer::new(input);
+        let token1 = lexer.next_token();
+        assert_eq!(token1.kind, Tokenkind::Ident);
+        assert_eq!(token1.literal, "variable_name");
+        let token2 = lexer.next_token();
+        assert_eq!(token2.kind, Tokenkind::Ident);
+        assert_eq!(token2.literal, "anotherVariable");
+        let token3 = lexer.next_token();
+        assert_eq!(token3.kind, Tokenkind::Ident);
+        assert_eq!(token3.literal, "_privateVar");
+    }
+    #[test]
+    fn test_read_operators() {
+        let input = "+ - * / % < > && || ! = == != >= <= ";
+        let mut lexer = Lexer::new(input);
+        let token1 = lexer.next_token();
+        assert_eq!(token1.kind, Tokenkind::Plus);
+        assert_eq!(token1.literal, "+");
+        let token2 = lexer.next_token();
+        assert_eq!(token2.kind, Tokenkind::Minus);
+        assert_eq!(token2.literal, "-");
+        let token3 = lexer.next_token();
+        assert_eq!(token3.kind, Tokenkind::Asterisk);
+        assert_eq!(token3.literal, "*");
+        let token4 = lexer.next_token();
+        assert_eq!(token4.kind, Tokenkind::Slash);
+        assert_eq!(token4.literal, "/");
+        let token5 = lexer.next_token();
+        assert_eq!(token5.kind, Tokenkind::Pencentage);
+        assert_eq!(token5.literal, "%");
+        let token6 = lexer.next_token();
+        assert_eq!(token6.kind, Tokenkind::Lthan);
+        assert_eq!(token6.literal, "<");
+        let token7 = lexer.next_token();
+        assert_eq!(token7.kind, Tokenkind::Gthan);
+        assert_eq!(token7.literal, ">");
+        let token8 = lexer.next_token();
+        assert_eq!(token8.kind, Tokenkind::And);
+        assert_eq!(token8.literal, "&&");
+        let token9 = lexer.next_token();
+        assert_eq!(token9.kind, Tokenkind::OR);
+        assert_eq!(token9.literal, "||");
+        let token10 = lexer.next_token();
+        assert_eq!(token10.kind, Tokenkind::Bang);
+        assert_eq!(token10.literal, "!");
+        let token11 = lexer.next_token();
+        assert_eq!(token11.kind, Tokenkind::Assign);
+        assert_eq!(token11.literal, "=");
+        let token12 = lexer.next_token();
+        assert_eq!(token12.kind, Tokenkind::Eq);
+        assert_eq!(token12.literal, "==");
+        let token13 = lexer.next_token();
+        assert_eq!(token13.kind, Tokenkind::NotEq);
+        assert_eq!(token13.literal, "!=");
+        let token14 = lexer.next_token();
+        assert_eq!(token14.kind, Tokenkind::Gthanoreq);
+        assert_eq!(token14.literal, ">=");
+        let token15 = lexer.next_token();
+        assert_eq!(token15.kind, Tokenkind::Lthanoreq);
+        assert_eq!(token15.literal, "<=");
+    }
 }

src/lexericals/tokenizer.rs

@@ -49,6 +49,8 @@ pub enum Tokenkind {
     NotEq,
     Lthan,
     Gthan,
+    Gthanoreq,
+    Lthanoreq,
     OR,
     And,
     Bang,
@@ -99,6 +101,8 @@ impl Display for Tokenkind {
             Tokenkind::NotEq => write!(f, "NotEq"),
             Tokenkind::Lthan => write!(f, "Lthan"),
             Tokenkind::Gthan => write!(f, "Gthan"),
+            Tokenkind::Gthanoreq => write!(f, "Gthanoreq"),
+            Tokenkind::Lthanoreq => write!(f, "Lthanoreq"),
             Tokenkind::OR => write!(f, "OR"),
             Tokenkind::And => write!(f, "And"),
             Tokenkind::Bang => write!(f, "Bang"),