diff --git a/.gitignore b/.gitignore
index f93a5ab..9d2e4a6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -66,3 +66,4 @@ testcases/string.xsharp.bc
 testcases/string.xsharp.o
 LLVMIR/test/temp
 XSharp/test/Parser/temp
+XSharp/test/Lexer/temp
diff --git a/XSharp/test/Lexer/arithmetic.xsharp b/XSharp/test/Lexer/arithmetic.xsharp
new file mode 100644
index 0000000..cf5d762
--- /dev/null
+++ b/XSharp/test/Lexer/arithmetic.xsharp
@@ -0,0 +1,22 @@
+void main()
+{
+    i32 n;
+    n = inputI32();
+
+    i32 i=0;
+    i32 a=1;
+    i32 b=1;
+    i32 c=1;
+    u8 d = 0;
+    while (i<n){
+        a = c = (-a)+b*c/66;
+        a = b % 3 / 2 + 4 + (b = 4);
+        b = c;
+        i=i+1;
+    }
+    print(a);
+    print(b);
+    print(c);
+    print(-c);
+    print(!(c == -1));
+}
diff --git a/XSharp/test/Lexer/arithmetic.xsharp_tokens.txt b/XSharp/test/Lexer/arithmetic.xsharp_tokens.txt
new file mode 100644
index 0000000..7456bce
--- /dev/null
+++ b/XSharp/test/Lexer/arithmetic.xsharp_tokens.txt
@@ -0,0 +1,121 @@
+1:5 Identifier:'void', 
+1:10 Identifier:'main', 
+1:10 OpenParenthesis:'(', 
+1:11 CloseParenthesis:')', 
+2:1 OpenBrace:'{', 
+3:8 Identifier:'i32', 
+3:10 Identifier:'n', 
+3:10 SentenceEnd:';', 
+4:6 Identifier:'n', 
+4:8 Operator:'=', 
+4:17 Identifier:'inputI32', 
+4:17 OpenParenthesis:'(', 
+4:18 CloseParenthesis:')', 
+4:19 SentenceEnd:';', 
+6:8 Identifier:'i32', 
+6:10 Identifier:'i', 
+6:11 Operator:'=', 
+6:12 Integer:'0', 
+6:12 SentenceEnd:';', 
+7:8 Identifier:'i32', 
+7:10 Identifier:'a', 
+7:11 Operator:'=', 
+7:12 Integer:'1', 
+7:12 SentenceEnd:';', 
+8:8 Identifier:'i32', 
+8:10 Identifier:'b', 
+8:11 Operator:'=', 
+8:12 Integer:'1', 
+8:12 SentenceEnd:';', 
+9:8 Identifier:'i32', 
+9:10 Identifier:'c', 
+9:11 Operator:'=', 
+9:12 Integer:'1', 
+9:12 SentenceEnd:';', 
+10:7 Identifier:'u8', 
+10:9 Identifier:'d', 
+10:11 Operator:'=', 
+10:13 Integer:'0', 
+10:13 SentenceEnd:';', 
+11:10 Keyword:'while', 
+11:11 OpenParenthesis:'(', 
+11:13 Identifier:'i', 
+11:14 Operator:'<', 
+11:15 Identifier:'n', 
+11:15 CloseParenthesis:')', 
+11:16 OpenBrace:'{', 
+12:10 Identifier:'a', 
+12:12 Operator:'=', 
+12:14 Identifier:'c', 
+12:16 Operator:'=', 
+12:17 OpenParenthesis:'(', 
+12:19 Operator:'-', 
+12:20 Identifier:'a', 
+12:20 CloseParenthesis:')', 
+12:22 Operator:'+', 
+12:23 Identifier:'b', 
+12:24 Operator:'*', 
+12:25 Identifier:'c', 
+12:26 Operator:'/', 
+12:28 Integer:'66', 
+12:28 SentenceEnd:';', 
+13:10 Identifier:'a', 
+13:12 Operator:'=', 
+13:14 Identifier:'b', 
+13:16 Operator:'%', 
+13:18 Integer:'3', 
+13:20 Operator:'/', 
+13:22 Integer:'2', 
+13:24 Operator:'+', 
+13:26 Integer:'4', 
+13:28 Operator:'+', 
+13:29 OpenParenthesis:'(', 
+13:31 Identifier:'b', 
+13:33 Operator:'=', 
+13:35 Integer:'4', 
+13:35 CloseParenthesis:')', 
+13:36 SentenceEnd:';', 
+14:10 Identifier:'b', 
+14:12 Operator:'=', 
+14:14 Identifier:'c', 
+14:14 SentenceEnd:';', 
+15:10 Identifier:'i', 
+15:11 Operator:'=', 
+15:12 Identifier:'i', 
+15:13 Operator:'+', 
+15:14 Integer:'1', 
+15:14 SentenceEnd:';', 
+16:5 CloseBrace:'}', 
+17:10 Identifier:'print', 
+17:10 OpenParenthesis:'(', 
+17:12 Identifier:'a', 
+17:12 CloseParenthesis:')', 
+17:13 SentenceEnd:';', 
+18:10 Identifier:'print', 
+18:10 OpenParenthesis:'(', 
+18:12 Identifier:'b', 
+18:12 CloseParenthesis:')', 
+18:13 SentenceEnd:';', 
+19:10 Identifier:'print', 
+19:10 OpenParenthesis:'(', 
+19:12 Identifier:'c', 
+19:12 CloseParenthesis:')', 
+19:13 SentenceEnd:';', 
+20:10 Identifier:'print', 
+20:10 OpenParenthesis:'(', 
+20:12 Operator:'-', 
+20:13 Identifier:'c', 
+20:13 CloseParenthesis:')', 
+20:14 SentenceEnd:';', 
+21:10 Identifier:'print', 
+21:10 OpenParenthesis:'(', 
+21:12 Operator:'!', 
+21:12 OpenParenthesis:'(', 
+21:14 Identifier:'c', 
+21:17 Operator:'==', 
+21:19 Operator:'-', 
+21:20 Integer:'1', 
+21:20 CloseParenthesis:')', 
+21:21 CloseParenthesis:')', 
+21:22 SentenceEnd:';', 
+22:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/XSharp/test/Lexer/class.xsharp b/XSharp/test/Lexer/class.xsharp
new file mode 100644
index 0000000..3126376
--- /dev/null
+++ b/XSharp/test/Lexer/class.xsharp
@@ -0,0 +1,47 @@
+class Foo{
+
+new(){
+    self.age = 0;
+}
+
+new(i32 a){
+    self.age = a;
+}
+
+void setAge(i32 age){
+    self.age = age;
+}
+
+i32 getAge(){
+    return self.age;
+}
+
+i32 age;
+
+}
+
+
+i32 main()
+{
+    i64 n = inputI32();
+
+    Foo[] c = new Foo[](n);
+
+    i64 i = n;
+    while(i-1>=0)
+    {
+        c[i - 1] = new Foo(inputI32());
+        i = i - 1;
+    }
+
+    double sum = 0;
+    i = n;
+    while(i - 1 >= 0){
+        sum = sum + c[i - 1].getAge();
+        i = i - 1;
+    }
+
+    print("Average age is:");
+    print(sum / n);
+    return 0;
+}
diff --git a/XSharp/test/Lexer/class.xsharp_tokens.txt b/XSharp/test/Lexer/class.xsharp_tokens.txt
new file mode 100644
index 0000000..3e16eaf
--- /dev/null
+++ b/XSharp/test/Lexer/class.xsharp_tokens.txt
@@ -0,0 +1,173 @@
+1:6 Keyword:'class', 
+1:10 Identifier:'Foo', 
+1:10 OpenBrace:'{', 
+3:4 Keyword:'new', 
+3:4 OpenParenthesis:'(', 
+3:5 CloseParenthesis:')', 
+3:6 OpenBrace:'{', 
+4:9 Identifier:'self', 
+4:10 Dot:'.', 
+4:13 Identifier:'age', 
+4:15 Operator:'=', 
+4:17 Integer:'0', 
+4:17 SentenceEnd:';', 
+5:1 CloseBrace:'}', 
+7:4 Keyword:'new', 
+7:4 OpenParenthesis:'(', 
+7:8 Identifier:'i32', 
+7:10 Identifier:'a', 
+7:10 CloseParenthesis:')', 
+7:11 OpenBrace:'{', 
+8:9 Identifier:'self', 
+8:10 Dot:'.', 
+8:13 Identifier:'age', 
+8:15 Operator:'=', 
+8:17 Identifier:'a', 
+8:17 SentenceEnd:';', 
+9:1 CloseBrace:'}', 
+11:5 Identifier:'void', 
+11:12 Identifier:'setAge', 
+11:12 OpenParenthesis:'(', 
+11:16 Identifier:'i32', 
+11:20 Identifier:'age', 
+11:20 CloseParenthesis:')', 
+11:21 OpenBrace:'{', 
+12:9 Identifier:'self', 
+12:10 Dot:'.', 
+12:13 Identifier:'age', 
+12:15 Operator:'=', 
+12:19 Identifier:'age', 
+12:19 SentenceEnd:';', 
+13:1 CloseBrace:'}', 
+15:4 Identifier:'i32', 
+15:11 Identifier:'getAge', 
+15:11 OpenParenthesis:'(', 
+15:12 CloseParenthesis:')', 
+15:13 OpenBrace:'{', 
+16:11 Keyword:'return', 
+16:16 Identifier:'self', 
+16:17 Dot:'.', 
+16:20 Identifier:'age', 
+16:20 SentenceEnd:';', 
+17:1 CloseBrace:'}', 
+19:4 Identifier:'i32', 
+19:8 Identifier:'age', 
+19:8 SentenceEnd:';', 
+21:1 CloseBrace:'}', 
+24:4 Identifier:'i32', 
+24:9 Identifier:'main', 
+24:9 OpenParenthesis:'(', 
+24:10 CloseParenthesis:')', 
+25:1 OpenBrace:'{', 
+26:8 Identifier:'i64', 
+26:10 Identifier:'n', 
+26:12 Operator:'=', 
+26:21 Identifier:'inputI32', 
+26:21 OpenParenthesis:'(', 
+26:22 CloseParenthesis:')', 
+26:23 SentenceEnd:';', 
+28:8 Identifier:'Foo', 
+28:8 OpenBracket:'[', 
+28:9 CloseBracket:']', 
+28:12 Identifier:'c', 
+28:14 Operator:'=', 
+28:18 Keyword:'new', 
+28:22 Identifier:'Foo', 
+28:22 OpenBracket:'[', 
+28:23 CloseBracket:']', 
+28:24 OpenParenthesis:'(', 
+28:26 Identifier:'n', 
+28:26 CloseParenthesis:')', 
+28:27 SentenceEnd:';', 
+30:8 Identifier:'i64', 
+30:10 Identifier:'i', 
+30:12 Operator:'=', 
+30:14 Identifier:'n', 
+30:14 SentenceEnd:';', 
+31:10 Keyword:'while', 
+31:10 OpenParenthesis:'(', 
+31:12 Identifier:'i', 
+31:13 Operator:'-', 
+31:14 Integer:'1', 
+31:16 Operator:'>=', 
+31:17 Integer:'0', 
+31:17 CloseParenthesis:')', 
+32:5 OpenBrace:'{', 
+33:10 Identifier:'c', 
+33:10 OpenBracket:'[', 
+33:12 Identifier:'i', 
+33:14 Operator:'-', 
+33:16 Integer:'1', 
+33:16 CloseBracket:']', 
+33:19 Operator:'=', 
+33:23 Keyword:'new', 
+33:27 Identifier:'Foo', 
+33:27 OpenParenthesis:'(', 
+33:36 Identifier:'inputI32', 
+33:36 OpenParenthesis:'(', 
+33:37 CloseParenthesis:')', 
+33:38 CloseParenthesis:')', 
+33:39 SentenceEnd:';', 
+34:10 Identifier:'i', 
+34:12 Operator:'=', 
+34:14 Identifier:'i', 
+34:16 Operator:'-', 
+34:18 Integer:'1', 
+34:18 SentenceEnd:';', 
+35:5 CloseBrace:'}', 
+37:11 Identifier:'double', 
+37:15 Identifier:'sum', 
+37:17 Operator:'=', 
+37:19 Integer:'0', 
+37:19 SentenceEnd:';', 
+38:6 Identifier:'i', 
+38:8 Operator:'=', 
+38:10 Identifier:'n', 
+38:10 SentenceEnd:';', 
+39:10 Keyword:'while', 
+39:10 OpenParenthesis:'(', 
+39:12 Identifier:'i', 
+39:14 Operator:'-', 
+39:16 Integer:'1', 
+39:19 Operator:'>=', 
+39:21 Integer:'0', 
+39:21 CloseParenthesis:')', 
+39:22 OpenBrace:'{', 
+40:12 Identifier:'sum', 
+40:14 Operator:'=', 
+40:18 Identifier:'sum', 
+40:20 Operator:'+', 
+40:22 Identifier:'c', 
+40:22 OpenBracket:'[', 
+40:24 Identifier:'i', 
+40:26 Operator:'-', 
+40:28 Integer:'1', 
+40:28 CloseBracket:']', 
+40:30 Dot:'.', 
+40:36 Identifier:'getAge', 
+40:36 OpenParenthesis:'(', 
+40:37 CloseParenthesis:')', 
+40:38 SentenceEnd:';', 
+41:10 Identifier:'i', 
+41:12 Operator:'=', 
+41:14 Identifier:'i', 
+41:16 Operator:'-', 
+41:18 Integer:'1', 
+41:18 SentenceEnd:';', 
+42:5 CloseBrace:'}', 
+44:10 Identifier:'print', 
+44:10 OpenParenthesis:'(', 
+44:28 String:'Average age is:', 
+44:28 CloseParenthesis:')', 
+44:29 SentenceEnd:';', 
+45:10 Identifier:'print', 
+45:10 OpenParenthesis:'(', 
+45:14 Identifier:'sum', 
+45:16 Operator:'/', 
+45:18 Identifier:'n', 
+45:18 CloseParenthesis:')', 
+45:19 SentenceEnd:';', 
+46:11 Keyword:'return', 
+46:13 Integer:'0', 
+46:13 SentenceEnd:';', 
+47:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/XSharp/test/Lexer/helloworld.xsharp b/XSharp/test/Lexer/helloworld.xsharp
new file mode 100644
index 0000000..c6f4f17
--- /dev/null
+++ b/XSharp/test/Lexer/helloworld.xsharp
@@ -0,0 +1,5 @@
+void main(){
+    print("Hello,World!");
+}
+
+
diff --git a/XSharp/test/Lexer/helloworld.xsharp_tokens.txt b/XSharp/test/Lexer/helloworld.xsharp_tokens.txt
new file mode 100644
index 0000000..ec59d41
--- /dev/null
+++ b/XSharp/test/Lexer/helloworld.xsharp_tokens.txt
@@ -0,0 +1,11 @@
+1:5 Identifier:'void', 
+1:10 Identifier:'main', 
+1:10 OpenParenthesis:'(', 
+1:11 CloseParenthesis:')', 
+1:12 OpenBrace:'{', 
+2:10 Identifier:'print', 
+2:10 OpenParenthesis:'(', 
+2:25 String:'Hello,World!', 
+2:25 CloseParenthesis:')', 
+2:26 SentenceEnd:';', 
+3:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/XSharp/test/Lexer/if.xsharp b/XSharp/test/Lexer/if.xsharp
new file mode 100644
index 0000000..d4f503c
--- /dev/null
+++ b/XSharp/test/Lexer/if.xsharp
@@ -0,0 +1,17 @@
+
+i64 main()
+{
+    i32 i = inputI32();
+    if(i == 3){
+        print(0);
+        if(i > 4){
+            print(2);
+        }else{
+            print(3);
+        }
+    }else{
+        print(1);
+    }
+    print(12);
+    return 10;
+}
diff --git a/XSharp/test/Lexer/if.xsharp_tokens.txt b/XSharp/test/Lexer/if.xsharp_tokens.txt
new file mode 100644
index 0000000..ef7c5e6
--- /dev/null
+++ b/XSharp/test/Lexer/if.xsharp_tokens.txt
@@ -0,0 +1,63 @@
+2:4 Identifier:'i64', 
+2:9 Identifier:'main', 
+2:9 OpenParenthesis:'(', 
+2:10 CloseParenthesis:')', 
+3:1 OpenBrace:'{', 
+4:8 Identifier:'i32', 
+4:10 Identifier:'i', 
+4:12 Operator:'=', 
+4:21 Identifier:'inputI32', 
+4:21 OpenParenthesis:'(', 
+4:22 CloseParenthesis:')', 
+4:23 SentenceEnd:';', 
+5:7 Keyword:'if', 
+5:7 OpenParenthesis:'(', 
+5:9 Identifier:'i', 
+5:12 Operator:'==', 
+5:14 Integer:'3', 
+5:14 CloseParenthesis:')', 
+5:15 OpenBrace:'{', 
+6:14 Identifier:'print', 
+6:14 OpenParenthesis:'(', 
+6:16 Integer:'0', 
+6:16 CloseParenthesis:')', 
+6:17 SentenceEnd:';', 
+7:11 Keyword:'if', 
+7:11 OpenParenthesis:'(', 
+7:13 Identifier:'i', 
+7:15 Operator:'>', 
+7:17 Integer:'4', 
+7:17 CloseParenthesis:')', 
+7:18 OpenBrace:'{', 
+8:18 Identifier:'print', 
+8:18 OpenParenthesis:'(', 
+8:20 Integer:'2', 
+8:20 CloseParenthesis:')', 
+8:21 SentenceEnd:';', 
+9:9 CloseBrace:'}', 
+9:14 Keyword:'else', 
+9:14 OpenBrace:'{', 
+10:18 Identifier:'print', 
+10:18 OpenParenthesis:'(', 
+10:20 Integer:'3', 
+10:20 CloseParenthesis:')', 
+10:21 SentenceEnd:';', 
+11:9 CloseBrace:'}', 
+12:5 CloseBrace:'}', 
+12:10 Keyword:'else', 
+12:10 OpenBrace:'{', 
+13:14 Identifier:'print', 
+13:14 OpenParenthesis:'(', 
+13:16 Integer:'1', 
+13:16 CloseParenthesis:')', 
+13:17 SentenceEnd:';', 
+14:5 CloseBrace:'}', 
+15:10 Identifier:'print', 
+15:10 OpenParenthesis:'(', 
+15:13 Integer:'12', 
+15:13 CloseParenthesis:')', 
+15:14 SentenceEnd:';', 
+16:11 Keyword:'return', 
+16:14 Integer:'10', 
+16:14 SentenceEnd:';', 
+17:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/XSharp/test/Lexer/isprime.xsharp b/XSharp/test/Lexer/isprime.xsharp
new file mode 100644
index 0000000..85e8ef0
--- /dev/null
+++ b/XSharp/test/Lexer/isprime.xsharp
@@ -0,0 +1,20 @@
+boolean isPrime(i32 x){
+    if(x <= 1)
+        return false;
+    i32 i = 2;
+    while(i*i <= x){
+        if(x%i == 0){return false;}
+        i=i+1;
+    }
+    return true;
+}
+
+i32 main()
+{
+    boolean a = true;
+    while(a){
+        i32 x = inputI32();
+        print(isPrime(x));
+    }
+    return 32;
+}
diff --git a/XSharp/test/Lexer/isprime.xsharp_tokens.txt b/XSharp/test/Lexer/isprime.xsharp_tokens.txt
new file mode 100644
index 0000000..2bec239
--- /dev/null
+++ b/XSharp/test/Lexer/isprime.xsharp_tokens.txt
@@ -0,0 +1,89 @@
+1:8 Identifier:'boolean', 
+1:16 Identifier:'isPrime', 
+1:16 OpenParenthesis:'(', 
+1:20 Identifier:'i32', 
+1:22 Identifier:'x', 
+1:22 CloseParenthesis:')', 
+1:23 OpenBrace:'{', 
+2:7 Keyword:'if', 
+2:7 OpenParenthesis:'(', 
+2:9 Identifier:'x', 
+2:12 Operator:'<=', 
+2:14 Integer:'1', 
+2:14 CloseParenthesis:')', 
+3:15 Keyword:'return', 
+3:21 Boolean:'false', 
+3:21 SentenceEnd:';', 
+4:8 Identifier:'i32', 
+4:10 Identifier:'i', 
+4:12 Operator:'=', 
+4:14 Integer:'2', 
+4:14 SentenceEnd:';', 
+5:10 Keyword:'while', 
+5:10 OpenParenthesis:'(', 
+5:12 Identifier:'i', 
+5:13 Operator:'*', 
+5:14 Identifier:'i', 
+5:17 Operator:'<=', 
+5:19 Identifier:'x', 
+5:19 CloseParenthesis:')', 
+5:20 OpenBrace:'{', 
+6:11 Keyword:'if', 
+6:11 OpenParenthesis:'(', 
+6:13 Identifier:'x', 
+6:14 Operator:'%', 
+6:15 Identifier:'i', 
+6:18 Operator:'==', 
+6:20 Integer:'0', 
+6:20 CloseParenthesis:')', 
+6:21 OpenBrace:'{', 
+6:28 Keyword:'return', 
+6:34 Boolean:'false', 
+6:34 SentenceEnd:';', 
+6:35 CloseBrace:'}', 
+7:10 Identifier:'i', 
+7:11 Operator:'=', 
+7:12 Identifier:'i', 
+7:13 Operator:'+', 
+7:14 Integer:'1', 
+7:14 SentenceEnd:';', 
+8:5 CloseBrace:'}', 
+9:11 Keyword:'return', 
+9:16 Boolean:'true', 
+9:16 SentenceEnd:';', 
+10:1 CloseBrace:'}', 
+12:4 Identifier:'i32', 
+12:9 Identifier:'main', 
+12:9 OpenParenthesis:'(', 
+12:10 CloseParenthesis:')', 
+13:1 OpenBrace:'{', 
+14:12 Identifier:'boolean', 
+14:14 Identifier:'a', 
+14:16 Operator:'=', 
+14:21 Boolean:'true', 
+14:21 SentenceEnd:';', 
+15:10 Keyword:'while', 
+15:10 OpenParenthesis:'(', 
+15:12 Identifier:'a', 
+15:12 CloseParenthesis:')', 
+15:13 OpenBrace:'{', 
+16:12 Identifier:'i32', 
+16:14 Identifier:'x', 
+16:16 Operator:'=', 
+16:25 Identifier:'inputI32', 
+16:25 OpenParenthesis:'(', 
+16:26 CloseParenthesis:')', 
+16:27 SentenceEnd:';', 
+17:14 Identifier:'print', 
+17:14 OpenParenthesis:'(', 
+17:22 Identifier:'isPrime', 
+17:22 OpenParenthesis:'(', 
+17:24 Identifier:'x', 
+17:24 CloseParenthesis:')', 
+17:25 CloseParenthesis:')', 
+17:26 SentenceEnd:';', 
+18:5 CloseBrace:'}', 
+19:11 Keyword:'return', 
+19:14 Integer:'32', 
+19:14 SentenceEnd:';', 
+20:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/XSharp/test/Lexer/recursive.xsharp b/XSharp/test/Lexer/recursive.xsharp
new file mode 100644
index 0000000..3b8271c
--- /dev/null
+++ b/XSharp/test/Lexer/recursive.xsharp
@@ -0,0 +1,12 @@
+i32 fib(i32 n){
+    if(n <= 0)
+        return -3;
+    if(n==1 || n==2)
+        return 1;
+    return fib(n-1) + fib(n-2);
+}
+
+i32 main() {
+    print(fib(inputI32()));
+    return 3;
+}
diff --git a/XSharp/test/Lexer/recursive.xsharp_tokens.txt b/XSharp/test/Lexer/recursive.xsharp_tokens.txt
new file mode 100644
index 0000000..799c5be
--- /dev/null
+++ b/XSharp/test/Lexer/recursive.xsharp_tokens.txt
@@ -0,0 +1,65 @@
+1:4 Identifier:'i32', 
+1:8 Identifier:'fib', 
+1:8 OpenParenthesis:'(', 
+1:12 Identifier:'i32', 
+1:14 Identifier:'n', 
+1:14 CloseParenthesis:')', 
+1:15 OpenBrace:'{', 
+2:7 Keyword:'if', 
+2:7 OpenParenthesis:'(', 
+2:9 Identifier:'n', 
+2:12 Operator:'<=', 
+2:14 Integer:'0', 
+2:14 CloseParenthesis:')', 
+3:15 Keyword:'return', 
+3:17 Operator:'-', 
+3:18 Integer:'3', 
+3:18 SentenceEnd:';', 
+4:7 Keyword:'if', 
+4:7 OpenParenthesis:'(', 
+4:9 Identifier:'n', 
+4:11 Operator:'==', 
+4:12 Integer:'1', 
+4:15 Operator:'||', 
+4:17 Identifier:'n', 
+4:19 Operator:'==', 
+4:20 Integer:'2', 
+4:20 CloseParenthesis:')', 
+5:15 Keyword:'return', 
+5:17 Integer:'1', 
+5:17 SentenceEnd:';', 
+6:11 Keyword:'return', 
+6:15 Identifier:'fib', 
+6:15 OpenParenthesis:'(', 
+6:17 Identifier:'n', 
+6:18 Operator:'-', 
+6:19 Integer:'1', 
+6:19 CloseParenthesis:')', 
+6:22 Operator:'+', 
+6:26 Identifier:'fib', 
+6:26 OpenParenthesis:'(', 
+6:28 Identifier:'n', 
+6:29 Operator:'-', 
+6:30 Integer:'2', 
+6:30 CloseParenthesis:')', 
+6:31 SentenceEnd:';', 
+7:1 CloseBrace:'}', 
+9:4 Identifier:'i32', 
+9:9 Identifier:'main', 
+9:9 OpenParenthesis:'(', 
+9:10 CloseParenthesis:')', 
+9:12 OpenBrace:'{', 
+10:10 Identifier:'print', 
+10:10 OpenParenthesis:'(', 
+10:14 Identifier:'fib', 
+10:14 OpenParenthesis:'(', 
+10:23 Identifier:'inputI32', 
+10:23 OpenParenthesis:'(', 
+10:24 CloseParenthesis:')', 
+10:25 CloseParenthesis:')', 
+10:26 CloseParenthesis:')', 
+10:27 SentenceEnd:';', 
+11:11 Keyword:'return', 
+11:13 Integer:'3', 
+11:13 SentenceEnd:';', 
+12:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/XSharp/test/Lexer/string.xsharp b/XSharp/test/Lexer/string.xsharp
new file mode 100644
index 0000000..765d30c
--- /dev/null
+++ b/XSharp/test/Lexer/string.xsharp
@@ -0,0 +1,30 @@
+class string extends A{
+    char[] data;
+ 
+	new(char[] chars) {
+        self.data = new char[](chars.length);
+        i64 i = 0;
+        while(i < chars.length) {
+            self.data[i] = chars[i];
+            i = i + 1;
+        }
+	}
+	
+	char charAt(i64 index) {
+		return self.data[index];
+	}
+	
+	char[] getData(){
+        print(self.data.length);
+        return self.data;
+    }
+}
+
+i32 main(){
+    string a = new string("H,world!\n");
+    print("H,world!\n"[1]);
+    print(a.getData());
+    a.getData()[3] = '$';
+    print(a.charAt(3));
+    return 0;
+}
diff --git a/XSharp/test/Lexer/string.xsharp_tokens.txt b/XSharp/test/Lexer/string.xsharp_tokens.txt
new file mode 100644
index 0000000..b5c8f0b
--- /dev/null
+++ b/XSharp/test/Lexer/string.xsharp_tokens.txt
@@ -0,0 +1,163 @@
+1:6 Keyword:'class', 
+1:13 Identifier:'string', 
+1:21 Keyword:'extends', 
+1:23 Identifier:'A', 
+1:23 OpenBrace:'{', 
+2:9 Identifier:'char', 
+2:9 OpenBracket:'[', 
+2:10 CloseBracket:']', 
+2:16 Identifier:'data', 
+2:16 SentenceEnd:';', 
+4:5 Keyword:'new', 
+4:5 OpenParenthesis:'(', 
+4:10 Identifier:'char', 
+4:10 OpenBracket:'[', 
+4:11 CloseBracket:']', 
+4:18 Identifier:'chars', 
+4:18 CloseParenthesis:')', 
+4:20 OpenBrace:'{', 
+5:13 Identifier:'self', 
+5:14 Dot:'.', 
+5:18 Identifier:'data', 
+5:20 Operator:'=', 
+5:24 Keyword:'new', 
+5:29 Identifier:'char', 
+5:29 OpenBracket:'[', 
+5:30 CloseBracket:']', 
+5:31 OpenParenthesis:'(', 
+5:37 Identifier:'chars', 
+5:38 Dot:'.', 
+5:44 Identifier:'length', 
+5:44 CloseParenthesis:')', 
+5:45 SentenceEnd:';', 
+6:12 Identifier:'i64', 
+6:14 Identifier:'i', 
+6:16 Operator:'=', 
+6:18 Integer:'0', 
+6:18 SentenceEnd:';', 
+7:14 Keyword:'while', 
+7:14 OpenParenthesis:'(', 
+7:16 Identifier:'i', 
+7:18 Operator:'<', 
+7:24 Identifier:'chars', 
+7:25 Dot:'.', 
+7:31 Identifier:'length', 
+7:31 CloseParenthesis:')', 
+7:33 OpenBrace:'{', 
+8:17 Identifier:'self', 
+8:18 Dot:'.', 
+8:22 Identifier:'data', 
+8:22 OpenBracket:'[', 
+8:24 Identifier:'i', 
+8:24 CloseBracket:']', 
+8:27 Operator:'=', 
+8:33 Identifier:'chars', 
+8:33 OpenBracket:'[', 
+8:35 Identifier:'i', 
+8:35 CloseBracket:']', 
+8:36 SentenceEnd:';', 
+9:14 Identifier:'i', 
+9:16 Operator:'=', 
+9:18 Identifier:'i', 
+9:20 Operator:'+', 
+9:22 Integer:'1', 
+9:22 SentenceEnd:';', 
+10:9 CloseBrace:'}', 
+11:2 CloseBrace:'}', 
+13:6 Identifier:'char', 
+13:13 Identifier:'charAt', 
+13:13 OpenParenthesis:'(', 
+13:17 Identifier:'i64', 
+13:23 Identifier:'index', 
+13:23 CloseParenthesis:')', 
+13:25 OpenBrace:'{', 
+14:9 Keyword:'return', 
+14:14 Identifier:'self', 
+14:15 Dot:'.', 
+14:19 Identifier:'data', 
+14:19 OpenBracket:'[', 
+14:25 Identifier:'index', 
+14:25 CloseBracket:']', 
+14:26 SentenceEnd:';', 
+15:2 CloseBrace:'}', 
+17:6 Identifier:'char', 
+17:6 OpenBracket:'[', 
+17:7 CloseBracket:']', 
+17:16 Identifier:'getData', 
+17:16 OpenParenthesis:'(', 
+17:17 CloseParenthesis:')', 
+17:18 OpenBrace:'{', 
+18:14 Identifier:'print', 
+18:14 OpenParenthesis:'(', 
+18:19 Identifier:'self', 
+18:20 Dot:'.', 
+18:24 Identifier:'data', 
+18:25 Dot:'.', 
+18:31 Identifier:'length', 
+18:31 CloseParenthesis:')', 
+18:32 SentenceEnd:';', 
+19:15 Keyword:'return', 
+19:20 Identifier:'self', 
+19:21 Dot:'.', 
+19:25 Identifier:'data', 
+19:25 SentenceEnd:';', 
+20:5 CloseBrace:'}', 
+21:1 CloseBrace:'}', 
+23:4 Identifier:'i32', 
+23:9 Identifier:'main', 
+23:9 OpenParenthesis:'(', 
+23:10 CloseParenthesis:')', 
+23:11 OpenBrace:'{', 
+24:11 Identifier:'string', 
+24:13 Identifier:'a', 
+24:15 Operator:'=', 
+24:19 Keyword:'new', 
+24:26 Identifier:'string', 
+24:26 OpenParenthesis:'(', 
+24:39 String:'H,world!
+', 
+24:39 CloseParenthesis:')', 
+24:40 SentenceEnd:';', 
+25:10 Identifier:'print', 
+25:10 OpenParenthesis:'(', 
+25:23 String:'H,world!
+', 
+25:23 OpenBracket:'[', 
+25:25 Integer:'1', 
+25:25 CloseBracket:']', 
+25:26 CloseParenthesis:')', 
+25:27 SentenceEnd:';', 
+26:10 Identifier:'print', 
+26:10 OpenParenthesis:'(', 
+26:12 Identifier:'a', 
+26:13 Dot:'.', 
+26:20 Identifier:'getData', 
+26:20 OpenParenthesis:'(', 
+26:21 CloseParenthesis:')', 
+26:22 CloseParenthesis:')', 
+26:23 SentenceEnd:';', 
+27:6 Identifier:'a', 
+27:7 Dot:'.', 
+27:14 Identifier:'getData', 
+27:14 OpenParenthesis:'(', 
+27:15 CloseParenthesis:')', 
+27:16 OpenBracket:'[', 
+27:18 Integer:'3', 
+27:18 CloseBracket:']', 
+27:21 Operator:'=', 
+27:25 Char:'$', 
+27:25 SentenceEnd:';', 
+28:10 Identifier:'print', 
+28:10 OpenParenthesis:'(', 
+28:12 Identifier:'a', 
+28:13 Dot:'.', 
+28:19 Identifier:'charAt', 
+28:19 OpenParenthesis:'(', 
+28:21 Integer:'3', 
+28:21 CloseParenthesis:')', 
+28:22 CloseParenthesis:')', 
+28:23 SentenceEnd:';', 
+29:11 Keyword:'return', 
+29:13 Integer:'0', 
+29:13 SentenceEnd:';', 
+30:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/XSharp/test/Lexer/types.xsharp b/XSharp/test/Lexer/types.xsharp
new file mode 100644
index 0000000..09c75fe
--- /dev/null
+++ b/XSharp/test/Lexer/types.xsharp
@@ -0,0 +1,12 @@
+i64 add(i32 a,i32 b){
+    return a+b;
+}
+
+i32 main()
+{
+    print(2);
+    print(2+1.1);
+    print(2/1.1);
+    print((2==1.1)||true);
+    return 21;
+}
diff --git a/XSharp/test/Lexer/types.xsharp_tokens.txt b/XSharp/test/Lexer/types.xsharp_tokens.txt
new file mode 100644
index 0000000..6bf7ad4
--- /dev/null
+++ b/XSharp/test/Lexer/types.xsharp_tokens.txt
@@ -0,0 +1,55 @@
+1:4 Identifier:'i64', 
+1:8 Identifier:'add', 
+1:8 OpenParenthesis:'(', 
+1:12 Identifier:'i32', 
+1:14 Identifier:'a', 
+1:14 Comma:',', 
+1:18 Identifier:'i32', 
+1:20 Identifier:'b', 
+1:20 CloseParenthesis:')', 
+1:21 OpenBrace:'{', 
+2:11 Keyword:'return', 
+2:13 Identifier:'a', 
+2:14 Operator:'+', 
+2:15 Identifier:'b', 
+2:15 SentenceEnd:';', 
+3:1 CloseBrace:'}', 
+5:4 Identifier:'i32', 
+5:9 Identifier:'main', 
+5:9 OpenParenthesis:'(', 
+5:10 CloseParenthesis:')', 
+6:1 OpenBrace:'{', 
+7:10 Identifier:'print', 
+7:10 OpenParenthesis:'(', 
+7:12 Integer:'2', 
+7:12 CloseParenthesis:')', 
+7:13 SentenceEnd:';', 
+8:10 Identifier:'print', 
+8:10 OpenParenthesis:'(', 
+8:12 Integer:'2', 
+8:13 Operator:'+', 
+8:16 DecimalFraction:'1.1', 
+8:16 CloseParenthesis:')', 
+8:17 SentenceEnd:';', 
+9:10 Identifier:'print', 
+9:10 OpenParenthesis:'(', 
+9:12 Integer:'2', 
+9:13 Operator:'/', 
+9:16 DecimalFraction:'1.1', 
+9:16 CloseParenthesis:')', 
+9:17 SentenceEnd:';', 
+10:10 Identifier:'print', 
+10:10 OpenParenthesis:'(', 
+10:11 OpenParenthesis:'(', 
+10:13 Integer:'2', 
+10:15 Operator:'==', 
+10:18 DecimalFraction:'1.1', 
+10:18 CloseParenthesis:')', 
+10:21 Operator:'||', 
+10:25 Boolean:'true', 
+10:25 CloseParenthesis:')', 
+10:26 SentenceEnd:';', 
+11:11 Keyword:'return', 
+11:14 Integer:'21', 
+11:14 SentenceEnd:';', 
+12:1 CloseBrace:'}'
\ No newline at end of file
diff --git a/test/update-test.py b/test/update-test.py
index 0ecd6d7..ac17d76 100755
--- a/test/update-test.py
+++ b/test/update-test.py
@@ -15,6 +15,7 @@
 bin_path = os.path.join(project_path, "bin")
 xsharpc_path = os.path.join(bin_path, "xsharpc")
 astprint_path = os.path.join(bin_path, "astprint")
+tokenize_path = os.path.join(bin_path, "tokenize")
 
 # update LLVM-IR
 llvm_test_path = os.path.join(project_path, "LLVMIR", "test")
@@ -35,3 +36,13 @@
 
     if file.endswith(".xsharp"):
         os.system(astprint_path + " " + file_path + " -o " + output_path)
+
+# update tokens
+path = os.path.join(project_path, "XSharp/test/Lexer")
+files = os.listdir(path)
+for file in files:
+    file_path = os.path.join(path, file)
+    output_path = file_path + "_tokens.txt"
+
+    if file.endswith(".xsharp"):
+        os.system(tokenize_path + " " + file_path + " -o " + output_path)
diff --git a/test/xsharp-test.py b/test/xsharp-test.py
index baf178a..9957102 100755
--- a/test/xsharp-test.py
+++ b/test/xsharp-test.py
@@ -24,6 +24,7 @@
 bin_path = os.path.join(project_path, "bin")
 xsharpc_path = os.path.join(bin_path, "xsharpc")
 astprint_path = os.path.join(bin_path, "astprint")
+tokenize_path = os.path.join(bin_path, "tokenize")
 
 total_test = 0
 failure_test = 0
@@ -94,6 +95,39 @@
         else:
             print("[{}] [Parser] Test passed {}:".format(total_test, source_path))
 
+# Test Lexer
+lexer_test_path = os.path.join(project_path, "XSharp/test/Lexer")
+files = os.listdir(llvm_test_path)
+
+for file in files:
+    file_path = os.path.join(lexer_test_path, file)
+
+    if file.endswith(".xsharp"):
+        source_path = file_path
+        ir_path = file_path + "_tokens.txt"
+        total_test += 1
+
+        with open(source_path, mode="r") as source:
+            os.makedirs(os.path.join(lexer_test_path, "temp"), exist_ok=True)
+            temp_path = os.path.join(lexer_test_path, "temp", file + "_tokens.txt")
+            code = os.system(tokenize_path + " " + file_path + " -o " + temp_path)
+
+        with open(temp_path, mode="r") as temp:
+            temp_lines = temp.readlines()
+
+        with open(ir_path, mode="r") as ir:
+            ir_lines = ir.readlines()
+
+        if ir_lines != temp_lines:
+            failure_test += 1
+            print("[{}] [Lexer] Test failed at {}:".format(total_test, source_path))
+
+            if args.verbose:
+                print("".join(list(difflib.ndiff(ir_lines, temp_lines))))
+        else:
+            print("[{}] [Lexer] Test passed {}:".format(total_test, source_path))
+
+
 
 print("===================Test Completed=======================")
 print("Total {} tests".format(total_test))