--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/testc3.py	Fri Nov 15 13:43:22 2013 +0100
@@ -0,0 +1,435 @@
+import c3
+import time, ppci, x86, ir
+import unittest
+import glob
+
+testsrc = """module test;
+
+/*
+ demo of the source that is correct :)
+*/ 
+var int c, d;
+var double e;
+var int f;
+
+const int A = 1337;
+
+function void test1()
+{
+    var int bdd;
+    var int a = 10;
+    bdd = 20;
+    var int buf;
+    var int i;
+    i = 2;
+    var int zero = i - 2;
+    if (i > 1)
+    {
+       buf = b + 22 * i - 13 + (55 * 2 *9-2) / 44 - 1;
+    }
+    else
+    {
+      ;;;
+    }
+
+    t2(2, 3);
+}
+
+function int t2(int a, int b)
+{
+   if (a > 0)
+   {
+      a = 2 + t2(a - 1, 10);
+   }
+
+   return a + b;
+}
+
+var int a, b;
+
+function int t3(int aap, int blah)
+{
+   if (a > blah and blah < 45 + 33 or 33 > aap or 6 > 2 and true)
+   {
+      a = 2 + t2(a - 1, 0);
+   }
+
+   return a + b;
+}
+
+var int hahaa = 23 * 2;
+
+
+"""
+
+class testLexer(unittest.TestCase):
+    def testUnexpectedCharacter(self):
+        snippet = """ var s \u6c34 """
+        with self.assertRaises(ppci.CompilerError):
+            list(c3.lexer.tokenize(snippet))
+
+    def testBlockComment(self):
+        snippet = """
+          /* Demo */
+          var int x = 0;
+        """
+        toks = ['var', 'ID', 'ID', '=', 'NUMBER', ';', 'END']
+        self.assertSequenceEqual([tok.typ for tok in c3.lexer.tokenize(snippet)], toks)
+
+    def testBlockCommentMultiLine(self):
+        snippet = """
+          /* Demo
+          bla1
+          bla2
+          */
+          var int x = 0;
+        """
+        toks = ['var', 'ID', 'ID', '=', 'NUMBER', ';', 'END']
+        self.assertSequenceEqual([tok.typ for tok in c3.lexer.tokenize(snippet)], toks)
+
+class testBuilder(unittest.TestCase):
+    def setUp(self):
+        self.diag = ppci.DiagnosticsManager()
+        self.builder = c3.Builder(self.diag)
+        self.diag.clear()
+
+    def testSrc(self):
+        self.expectOK(testsrc)
+
+    def expectErrors(self, snippet, rows):
+        """ Helper to test for expected errors on rows """
+        ircode = self.builder.build(snippet)
+        actualErrors = [err.row for err in self.diag.diags]
+        if rows != actualErrors:
+            self.diag.printErrors(snippet)
+        self.assertSequenceEqual(rows, actualErrors)
+        self.assertFalse(ircode)
+
+    def expectOK(self, snippet, pack_dir=None):
+        ircode = self.builder.build(snippet, pack_dir=pack_dir)
+        if not ircode:
+            self.diag.printErrors(snippet)
+        self.assertTrue(ircode)
+        return ircode
+
+    def testPackage(self):
+        p1 = """module p1;
+        type int A;
+        """
+        self.assertTrue(self.builder.build(p1))
+        p2 = """module p2;
+        import p1;
+        var A b;
+        """
+        self.expectOK(p2)
+
+    def testFunctArgs(self):
+      snippet = """
+         module testargs;
+         function void t2(int a, double b)
+         {
+            t2(2, 2);
+            t2(2);
+            t2(1, 1.2);
+         }
+      """
+      self.expectErrors(snippet, [5, 6])
+
+    def testExpressions(self):
+      snippet = """
+         module test;
+         function void t(int a, double b)
+         {
+            var int a2;
+            var bool c;
+
+            a2 = b * a;
+            c = a;
+            c = b > 1;
+         }
+      """
+      self.expectErrors(snippet, [8, 9, 10])
+
+    def testExpression1(self):
+      snippet = """
+         module testexpr1;
+         function void t()
+         {
+            var int a, b, c;
+            a = 1;
+            b = a * 2 + a * a;
+            c = b * a - 3;
+         }
+      """
+      self.expectOK(snippet)
+
+    def testEmpty(self):
+      snippet = """
+      module A
+      """
+      self.expectErrors(snippet, [3])
+
+    def testEmpty2(self):
+      snippet = ""
+      self.expectErrors(snippet, [1])
+
+    def testRedefine(self):
+      snippet = """
+      module test;
+      var int a;
+      var int b;
+      var int a;
+      """
+      self.expectErrors(snippet, [5])
+
+    def testWhile(self):
+      snippet = """
+      module tstwhile;
+      var int a;
+      function void t()
+      {
+         var int i = 0;
+         while (i < 1054)
+         {
+            i = i + 3;
+            a = a + i;
+         }
+
+         while(true)
+         {
+         }
+
+         while(false)
+         {
+         }
+      }
+      """
+      self.expectOK(snippet)
+
+    def testIf(self):
+        snippet = """
+      module tstIFF;
+      function void t(int b)
+      {
+         var int a;
+         a = 2;
+         if (a > b)
+         {
+            if (a > 1337)
+            {
+               b = 2;
+            }
+         }
+         else
+         {
+            b = 1;
+         }
+
+         return b;
+      }
+        """
+        self.expectOK(snippet)
+
+    def testTypeDef(self):
+        snippet = """
+         module testtypedef;
+         type int my_int;
+         function void t()
+         {
+            var my_int a;
+            var int b;
+            a = 2;
+            b = a + 2;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testLocalVariable(self):
+        snippet = """
+         module testlocalvar;
+         function void t()
+         {
+            var int a, b;
+            a = 2;
+            b = a + 2;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testUnknownType(self):
+        snippet = """module testlocalvar;
+         function void t()
+         {
+            var int2 a;
+         }
+        """
+        self.expectErrors(snippet, [4])
+
+    def testStruct1(self):
+        snippet = """
+         module teststruct1;
+         function void t()
+         {
+            var struct {int x, y;} a;
+            a.x = 2;
+            a.y = a.x + 2;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testPointerType1(self):
+        snippet = """
+         module testpointer1;
+         var int* pa;
+         function void t()
+         {
+            var int a;
+            pa = &a;
+            *pa = 22;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testPointerType(self):
+        snippet = """
+         module testpointer;
+         var int* pa, pb;
+         function void t(int a, double b)
+         {
+            var int a2;
+            a2 = a; // parameters cannot be escaped for now..
+            pa = &a2;
+            pb = pa;
+            *pa = 22;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testPointerTypeInCorrect(self):
+        snippet = """
+         module testpointerincorrect;
+         var int* pa;
+         function void t(int a, double b)
+         {
+            pa = 2; // type conflict
+            pa = &a;
+            pa = &2;
+            &a = pa; // No valid lvalue
+            **pa = 22; // Cannot deref int
+         }
+        """
+        self.expectErrors(snippet, [6, 9, 10])
+
+    def testPointerTypeIr(self):
+        snippet = """
+         module testptr_ir;
+         function void t()
+         {
+            var int* a;
+            a = cast<int*>(40);
+            *a = 2;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testPointerTypeIr2(self):
+        snippet = """
+         module testptr_ir;
+         type struct {int x,y;}* gpio;
+         function void t()
+         {
+            var gpio a;
+            a = cast<gpio>(40);
+            a->x = 2;
+            a->y = a->x - 14;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testWrongCast(self):
+        snippet = """
+         module testptr_ir;
+         type struct {int x,y;}* gpio;
+         function void t()
+         {
+            var gpio a;
+            *cast<gpio>(*a);
+         }
+        """
+        # TODO: remove the duplicate error:
+        self.expectErrors(snippet, [7, 7])
+
+    def testComplexType(self):
+        snippet = """
+         module testpointer;
+         type int my_int;
+
+         type struct {
+          int x, y;
+         } point;
+
+         type struct {
+           int mem1;
+           int memb2;
+           point P1;
+         } my_struct;
+
+         type my_struct* my_sptr;
+         var int* pa;
+
+         function void t(int a, int b, my_sptr x)
+         {
+            var my_struct *msp;
+
+            var my_struct u, v;
+            var point *pt;
+
+            pt = &msp->P1;
+            msp = x;
+            *pa = 22 + u.mem1 * v.memb2 - u.P1.x;
+            x->memb2 = *pa + a * b;
+
+            msp->P1.x = a * x->P1.y;
+         }
+        """
+        self.expectOK(snippet)
+
+    def testExamples(self):
+        """ Test all examples in the c3/examples directory """
+        example_filenames = glob.glob('./c3/examples/*.c3')
+        for filename in example_filenames:
+            with open(filename, 'r') as f:
+                src = f.read()
+            self.expectOK(src, pack_dir='./c3/examples')
+
+    def test2(self):
+        # testsrc2 is valid code:
+        snippet = """
+        module test2;
+
+        function void tst()
+        {
+           var int a, b;
+           a = 2 * 33 - 12;
+           b = a * 2 + 13;
+           a = b + a;
+           if (a > b and b == 3)
+           {
+              var int x = a;
+              x = b * 2 - a;
+              a = x*x;
+           }
+           else
+           {
+              a = b + a;
+           }
+        }
+
+        """
+        ircode = self.expectOK(snippet)
+        self.assertEqual(1, len(ircode.Functions))
+
+if __name__ == '__main__':
+    unittest.main()
+
+