Re-added unittest folder.

.gitignore

@@ -310,3 +310,9 @@ xcuserdata/
 *.xcuserstate
 
 *.xcworkspacedata
+
+test/fuzzy/.DS_Store
+
+test/fuzzy/2017-04-04/.DS_Store
+
+test/unittest/.DS_Store

test/unittest/01-syntax/class_declaration.gravity

@@ -0,0 +1,44 @@
+#unittest {
+	name: "Test classes declaration with both static and non static members.";
+	error: NONE;
+};
+
+// class declarations
+class bar {
+	// class var
+	static var a1 = 10;
+	static var a2 = 20;
+	
+	// class const
+	static var b1 = 100;
+	static var b2 = 200;
+	
+	// instance var
+	var c1 = 1000;
+	var c2 = 2000;
+	
+	// instance const
+	const d1 = 10000;
+	const d2 = 20000;
+	
+	static func f1() {
+		return a1+a2+b1+b2;
+	}
+	
+	func f2() {
+		return c1+c2+d1+d2;
+	}
+}
+
+class foo:bar {
+	var e1 = 10;
+	var e2 = 20;
+	
+	func init() {
+		e1 = 100;
+	}
+}
+
+func main() {
+	return;
+}

test/unittest/01-syntax/empty.gravity

@@ -0,0 +1,4 @@
+#unittest {
+	name: "Empty file.";
+	error: RUNTIME;
+};

test/unittest/01-syntax/empty_enum.gravity

@@ -0,0 +1,9 @@
+#unittest {
+	name: "Testing empty enum.";
+	error: SYNTAX;
+	error_row: 8;
+	error_col: 1;
+};
+
+enum math {
+}

test/unittest/01-syntax/empty_return.gravity

@@ -0,0 +1,9 @@
+#unittest {
+	name: "Test empty return.";
+	error: NONE;
+	result: null;
+};
+
+func main() {
+	return;
+}

test/unittest/01-syntax/func_error_params.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Test missing parameters.";
+	error: SYNTAX;
+	error_row:8;
+	error_col:9;
+};
+
+func f1 {
+	return 1;
+}

test/unittest/01-syntax/module_declaration.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Test module declaration.";
+	error: RUNTIME;
+};
+
+module m1 {
+	var a = 100;
+	func f1() {return a;}
+}
+
+module m2 {
+	var a = 200;
+	func f1() {return a;}
+}

test/unittest/01-syntax/var_in_if.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Test variable declaration in if flow statement.";
+	error: SYNTAX;
+	error_row: 9;
+	error_col: 6;
+};
+
+func main() {
+	if (var a) {};
+}

test/unittest/01-syntax/var_in_repeat.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Test variable declaration in repeat loop statement.";
+	error: SYNTAX;
+	error_row: 10;
+	error_col: 11;
+};
+
+func main() {
+	repeat {
+	} while (var a);
+}

test/unittest/01-syntax/var_in_switch.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Test variable declaration in switch flow statement.";
+	error: SYNTAX;
+	error_row: 9;
+	error_col: 10;
+};
+
+func main() {
+	switch (var a) {
+	};
+}

test/unittest/01-syntax/var_in_while.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Test variable declaration in while loop statement.";
+	error: SYNTAX;
+	error_row: 9;
+	error_col: 9;
+};
+
+func main() {
+	while (var a) {
+	};
+}

test/unittest/02-semantic_step1/class1_redeclared.gravity

@@ -0,0 +1,12 @@
+#unittest {
+	name: "Class redeclared.";
+	error: SEMANTIC;
+	error_row: 11;
+	error_col: 1;
+};
+
+class c {
+}
+
+func c() {
+}

test/unittest/02-semantic_step1/class2_internal_redeclared.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Class internal redeclared.";
+	error: SEMANTIC;
+	error_row: 10;
+	error_col: 2;
+};
+
+class c {
+	var a;
+	func a() {return 1;}
+}

test/unittest/02-semantic_step1/enum1_redeclared.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Enum redeclared.";
+	error: SEMANTIC;
+	error_row: 12;
+	error_col: 1;
+};
+
+enum list1{
+	one = 1
+}
+
+enum list1{
+	two = 2
+}

test/unittest/02-semantic_step1/enum2_internal_redeclared.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Enum item redeclared.";
+	error: SYNTAX;
+	error_row: 10;
+	error_col: 2;
+};
+
+enum list1{
+	one = 1,
+	one = 2
+}

test/unittest/02-semantic_step1/function_redeclared.gravity

@@ -0,0 +1,9 @@
+#unittest {
+	name: "Test function redeclared.";
+	error: SEMANTIC;
+	error_row: 9;
+	error_col: 1;
+};
+
+func foo() {return 1;}
+func foo() {return 1;}

test/unittest/02-semantic_step1/local_variables_number.gravity

@@ -0,0 +1,28 @@
+#unittest {
+	name: "Test maximum number of local variables.";
+	error: SEMANTIC;
+};
+
+func main() {
+	var a001,a002,a003,a004,a005,a006,a007,a008,a009,a010;
+	var a011,a012,a013,a014,a015,a016,a017,a018,a019,a020;
+	var b001,b002,b003,b004,b005,b006,b007,b008,b009,b010;
+	var b011,b012,b013,b014,b015,b016,b017,b018,b019,b020;
+	var c001,c002,c003,c004,c005,c006,c007,c008,c009,c010;
+	var c011,c012,c013,c014,c015,c016,c017,c018,c019,c020;
+	var d001,d002,d003,d004,d005,d006,d007,d008,d009,d010;
+	var d011,d012,d013,d014,d015,d016,d017,d018,d019,d020;
+	var e001,e002,e003,e004,e005,e006,e007,e008,e009,e010;
+	var e011,e012,e013,e014,e015,e016,e017,e018,e019,e020;
+	var f001,f002,f003,f004,f005,f006,f007,f008,f009,f010;
+	var f011,f012,f013,f014,f015,f016,f017,f018,f019,f020;
+	var g001,g002,g003,g004,g005,g006,g007,g008,g009,g010;
+	var g011,g012,g013,g014,g015,g016,g017,g018,g019,g020;
+	var h001,h002,h003,h004,h005,h006,h007,h008,h009,h010;
+	var h011,h012,h013,h014,h015,h016,h017,h018,h019,h020;
+	var i001,i002,i003,i004,i005,i006,i007,i008,i009,i010;
+	var i011,i012,i013,i014,i015,i016,i017,i018,i019,i020;
+	var l001,l002,l003,l004,l005,l006,l007,l008,l009,l010;
+	var l011,l012,l013,l014,l015,l016,l017,l018,l019,l020;
+	var m001;
+}

test/unittest/02-semantic_step1/module1_redeclared.gravity

@@ -0,0 +1,12 @@
+#unittest {
+	name: "Module redeclared.";
+	error: SEMANTIC;
+	error_row: 11;
+	error_col: 1;
+};
+
+module module1 {
+}
+
+module module1 {
+}

test/unittest/02-semantic_step1/module2_internal_redeclared.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Module internal redeclared.";
+	error: SEMANTIC;
+	error_row: 10;
+	error_col: 2;
+};
+
+module module1 {
+	var v1;
+	func v1() {return 1;}
+}

test/unittest/02-semantic_step1/var_redeclared.gravity

@@ -0,0 +1,9 @@
+#unittest {
+	name: "Test variable redeclared.";
+	error: SEMANTIC;
+	error_row: 9;
+	error_col: 5;
+};
+
+var v1;
+var v1;

test/unittest/03-semantic_step2/class1_access_specifier.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Testing class access specifier in global.";
+	error: SEMANTIC;
+	error_row: 8;
+	error_col: 8;
+};
+
+public class math {
+	
+}

test/unittest/03-semantic_step2/class2_access_specifier.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Testing class access specifier in a function.";
+	error: SEMANTIC;
+	error_row: 9;
+	error_col: 9;
+};
+
+func foo() {
+	public class math {
+	}
+}

test/unittest/03-semantic_step2/class_container.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Testing class container (module cannot be declared inside a class).";
+	error: SEMANTIC;
+	error_row: 13;
+	error_col: 2;
+};
+
+class foo {
+	var a;
+	func b() {return 1;}
+	class c {}
+	enum d { one = 1}
+	module e {var one;}
+}

test/unittest/03-semantic_step2/enum1_access_specifier.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Testing enum access specifier in global.";
+	error: SEMANTIC;
+	error_row: 8;
+	error_col: 8;
+};
+
+public enum math {
+	one = 1
+}

test/unittest/03-semantic_step2/enum2_access_specifier.gravity

@@ -0,0 +1,12 @@
+#unittest {
+	name: "Testing enum access specifier in a function.";
+	error: SEMANTIC;
+	error_row: 9;
+	error_col: 9;
+};
+
+func foo() {
+	public enum math {
+		one = 1
+	}
+}

test/unittest/03-semantic_step2/for1_identifier_not_found.gravity

@@ -0,0 +1,12 @@
+#unittest {
+	name: "Testing identifier not found in for loop.";
+	error: SEMANTIC;
+	error_row: 10;
+	error_col: 7;
+};
+
+func foo() {
+	var a;
+	for (i in a) {
+	}
+}

test/unittest/03-semantic_step2/func1_access_specifier.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Testing function access specifier in global.";
+	error: SEMANTIC;
+	error_row: 8;
+	error_col: 8;
+};
+
+public func foo() {
+	return 1;
+}

test/unittest/03-semantic_step2/func2_access_specifier.gravity

@@ -0,0 +1,12 @@
+#unittest {
+	name: "Testing function access specifier in function.";
+	error: SEMANTIC;
+	error_row: 9;
+	error_col: 9;
+};
+
+func bar() {
+	public func foo() {
+		return 1;
+	}
+}

test/unittest/03-semantic_step2/func3_identifier_redeclared.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Testing function closure declaration redeclared.";
+	error: SEMANTIC;
+	error_row: 10;
+	error_col: 2;
+};
+
+func foo() {
+	var bar;
+	func bar() {return 1;}
+}

test/unittest/03-semantic_step2/func4_identifier_redeclared.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Testing local class declaration redeclared.";
+	error: SEMANTIC;
+	error_row: 10;
+	error_col: 2;
+};
+
+func foo() {
+	var bar;
+	class bar {}
+}

test/unittest/03-semantic_step2/func_container.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Testing function container (module cannot be declared inside a function).";
+	error: SEMANTIC;
+	error_row: 13;
+	error_col: 2;
+};
+
+func foo() {
+	var a;
+	func b() {return 1;}
+	class c {}
+	enum d { one = 1}
+	module e {var one;}
+}

test/unittest/03-semantic_step2/invalid_condition_if.gravity

@@ -0,0 +1,17 @@
+#unittest {
+	name: "Semantic, If statement condition, Assignment not allowed here.";
+	error: SEMANTIC;
+	error_row: 11;
+	error_col: 6;
+};
+
+func main () {
+	var i,v = 0;
+
+	if (i = 1) {	// Assignment not allowed as a condition
+		v = 1;
+		v = 2;
+	} else v = 3;
+
+return v;
+}

test/unittest/03-semantic_step2/invalid_condition_while.gravity

@@ -0,0 +1,18 @@
+#unittest {
+	name: "Semantic, While loop condition, Assignment not allowed here.";
+	error: SEMANTIC;
+	error_row: 12;
+	error_col: 9;
+};
+
+func main () {
+	var i,sum = 0;
+
+	// assignment instead of a condition
+	while (i = 50) {
+		sum += i;
+		i += 1;
+	}
+
+	return sum;
+}

test/unittest/03-semantic_step2/module_access_specifier.gravity

@@ -0,0 +1,9 @@
+#unittest {
+	name: "Testing module access specifier.";
+	error: SEMANTIC;
+	error_row: 8;
+	error_col: 8;
+};
+
+public module math {
+}

test/unittest/03-semantic_step2/module_container.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Testing module container (module cannot be declared inside a module).";
+	error: SEMANTIC;
+	error_row: 13;
+	error_col: 2;
+};
+
+module foo {
+	var a;
+	func b() {return 1;}
+	class c {}
+	enum d { one = 1}
+	module e {var one;}
+}

test/unittest/03-semantic_step2/override_property.gravity

@@ -0,0 +1,16 @@
+#unittest {
+	name: "Test property overriden warning.";
+	error: WARNING;
+	error_row: 14;
+	error_col: 2;
+};
+
+class class1 {
+	var a;
+	func f1() {return a;}
+}
+
+class class2:class1 {
+	var a;
+	func f1() {return a;}
+}

test/unittest/03-semantic_step2/var1_access_specifier.gravity

@@ -0,0 +1,8 @@
+#unittest {
+	name: "Testing var access specifier in global.";
+	error: SEMANTIC;
+	error_row: 8;
+	error_col: 8;
+};
+
+public var a;

test/unittest/03-semantic_step2/var2_access_specifier.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Testing var access specifier in function.";
+	error: SEMANTIC;
+	error_row: 9;
+	error_col: 9;
+};
+
+func foo() {
+	public var a;
+}

test/unittest/03-semantic_step2/var_container.gravity

@@ -0,0 +1,8 @@
+#unittest {
+	name: "Testing anonymous function declaration.";
+	error: NONE;
+};
+
+func main() {
+	var a = func() {return 1;};
+}

test/unittest/04-codegen/assignment1.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Test local assignment.";
+	error: NONE;
+	result: 10;
+};
+
+func main() {
+	var a;
+	a = 10;
+	return a;
+}

test/unittest/04-codegen/assignment2.gravity

@@ -0,0 +1,13 @@
+#unittest {
+	name: "Test file assignment.";
+	error: NONE;
+	result: 10;
+};
+
+var a;
+
+func main() {
+	var a = 20;
+	file.a = 10;
+	return file.a;
+}

test/unittest/04-codegen/assignment3.gravity

@@ -0,0 +1,12 @@
+#unittest {
+	name: "Test global literal assignment.";
+	error: NONE;
+	result: 10;
+};
+
+var a;
+
+func main() {
+	a = 10;
+	return a;
+}

test/unittest/04-codegen/assignment4.gravity

@@ -0,0 +1,13 @@
+#unittest {
+	name: "Test global literal assignment.";
+	error: NONE;
+	result: 10;
+};
+
+var a;
+
+func main() {
+	var a = 20;
+	a = 10;
+	return a;
+}

test/unittest/04-codegen/class/1.gravity

@@ -0,0 +1,25 @@
+#unittest {
+	name: "Test class instantiation.";
+	error: NONE;
+	result: 3;
+};
+
+class foo {
+	var a = 1;
+	var b = 2;
+	
+	func f1() {
+		return self.a;
+	}
+	
+	func f2() {
+		return b;
+	}
+}
+
+func main() {
+	var f = foo();
+	var a = f.f1();
+	var b = f.f2();
+	return a+b;
+}

test/unittest/04-codegen/class/12.gravity

@@ -0,0 +1,19 @@
+#unittest {
+	name: "Test combined init/call init.";
+	error: NONE;
+	result: 150;
+};
+
+// no init
+class c1 {
+	var p1;
+	func f1() {
+		p1 = 150;
+		return p1;
+	}
+}
+
+func main() {
+	var x1 = c1().f1();
+	return x1;
+}

test/unittest/04-codegen/class/13.gravity

@@ -0,0 +1,19 @@
+#unittest {
+	name: "Test self set/get init.";
+	error: NONE;
+	result: 150;
+};
+
+// no init
+class c1 {
+	var p1;
+	func f1() {
+		self.p1 = 150;
+		return self.p1;
+	}
+}
+
+func main() {
+	var x1 = c1().f1();
+	return x1;
+}

test/unittest/04-codegen/class/2.gravity

@@ -0,0 +1,23 @@
+#unittest {
+	name: "Test class instantiation.";
+	error: NONE;
+	result: 3;
+};
+
+class foo {
+	var a = 1;
+	var b = 2;
+	
+	func f1() {
+		return self.a;
+	}
+	
+	func f2() {
+		return b;
+	}
+}
+
+func main() {
+	var f = foo();
+	return f.f1()+f.f2();
+}

test/unittest/04-codegen/class/3.gravity

@@ -0,0 +1,23 @@
+#unittest {
+	name: "Test class instantiation.";
+	error: NONE;
+	result: 3;
+};
+
+class foo {
+	var a = 1;
+	var b = 2;
+	
+	func f1() {
+		return a;
+	}
+	
+	func f2() {
+		return b;
+	}
+}
+
+func main() {
+	var f = foo();
+	return f.f1()+f.f2();
+}

test/unittest/04-codegen/class/4.gravity

@@ -0,0 +1,23 @@
+#unittest {
+	name: "Test class instantiation.";
+	error: NONE;
+	result: 3;
+};
+
+class foo {
+	var a = 1;
+	var b = 2;
+	
+	func f1() {
+		return self.a;
+	}
+	
+	func f2() {
+		return self.b;
+	}
+}
+
+func main() {
+	var f = foo();
+	return f.f1()+f.f2();
+}

test/unittest/04-codegen/class/5.gravity

@@ -0,0 +1,25 @@
+#unittest {
+	name: "Test class instantiation.";
+	error: NONE;
+	result: 30;
+};
+
+class foo {
+	var a = 1;
+	var b = 2;
+	
+	func f1() {
+		return a;
+	}
+	
+	func f2() {
+		return b;
+	}
+}
+
+func main() {
+	var f = foo();
+	f.a = 10;
+	f.b = 20;
+	return f.f1()+f.f2();
+}

test/unittest/04-codegen/class/6.gravity

@@ -0,0 +1,27 @@
+#unittest {
+	name: "Test class instantiation.";
+	error: NONE;
+	result: 783;
+};
+
+class foo {
+	var a = 1;
+	var b = 2;
+	
+	func f1() {
+		return self.a+self.b;
+	}
+	
+	func f2() {
+		self.a = 50;
+		self.b = 730;
+	}
+}
+
+func main() {
+	var f = foo();
+	var n1 = f.f1();
+	f.f2();
+	var n2 = f.f1();
+	return n1+n2;
+}

test/unittest/04-codegen/class/7.gravity

@@ -0,0 +1,27 @@
+#unittest {
+	name: "Test class instantiation.";
+	error: NONE;
+	result: 783;
+};
+
+class foo {
+	var a = 1;
+	var b = 2;
+	
+	func f1() {
+		return a+b;
+	}
+	
+	func f2() {
+		a = 50;
+		b = 730;
+	}
+}
+
+func main() {
+	var f = foo();
+	var n1 = f.f1();
+	f.f2();
+	var n2 = f.f1();
+	return n1+n2;
+}

test/unittest/04-codegen/class/8.gravity

@@ -0,0 +1,21 @@
+#unittest {
+	name: "Test class ivar (a) and lookup (b).";
+	error: NONE;
+	result: 3;
+};
+
+class foo {
+	var a = 1;
+	func b() {return 2;}
+	
+	func f1() {
+		var n1 = a;
+		var n2 = b;
+		return n1+n2();
+	}
+}
+
+func main() {
+	var f = foo();
+	return f.f1();
+}

test/unittest/04-codegen/complex_expression.gravity

@@ -0,0 +1,12 @@
+#unittest {
+	name: "Test complex expression.";
+	error: NONE;
+	result: 1000;
+};
+
+func main() {
+	var a = 50;
+	var b = 20;
+	var c = 200;
+	return (a*2 + b*5) * 4 + c;
+}

test/unittest/04-codegen/fibonacci.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Test recursive call with Fibonacci.";
+	error: NONE;
+	result: 6765;
+};
+
+func fibonacci (n) {
+	if (n<2) return n;
+	return fibonacci(n-2) + fibonacci(n-1);
+}
+
+func main() {
+	return fibonacci(20);
+}

test/unittest/04-codegen/file_access.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Test file module access.";
+	error: NONE;
+	result: 50;
+};
+
+var a = 50;
+func main() {
+	var a = 30;
+	return file.a;
+}

test/unittest/04-codegen/keywords/_func.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Test _func keyword.";
+	error: NONE;
+	result: 6765;
+};
+
+func fibonacci (n) {
+	if (n<2) return n;
+	return _func(n-2) + _func(n-1);
+}
+
+func main() {
+	return fibonacci(20);
+}

test/unittest/04-codegen/list_map/list1.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Test list load.";
+	error: NONE;
+	result: 13;
+};
+
+func main() {
+	var list = [10,11,12,13,14,15,16,17,18,19];
+	return list[3];
+}

test/unittest/04-codegen/list_map/list2.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Test list store.";
+	error: NONE;
+	result: 444;
+};
+
+func main() {
+	var list = [10,11,12,13,14,15,16,17,18,19];
+	list[3]= 444;
+	return list[3];
+}

test/unittest/04-codegen/list_map/map1.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Test map load.";
+	error: NONE;
+	result: 41;
+};
+
+func main() {
+	var map = ["Marco":41, "Chiara":30, "Monica":32];
+	return map["Marco"];
+}

test/unittest/04-codegen/list_map/map2.gravity

@@ -0,0 +1,11 @@
+#unittest {
+	name: "Test map store.";
+	error: NONE;
+	result: 42;
+};
+
+func main() {
+	var map = ["Marco":41, "Chiara":30, "Monica":32];
+	map["Marco"]= 42;
+	return map["Marco"];
+}

test/unittest/04-codegen/literals.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Test literals expression.";
+	error: NONE;
+	result: 4468.1415;
+};
+
+func main() {
+	var n1 = 100;		// decimal 100
+	var n2 = 0xFF;		// hex 255
+	var n3 = 0b1111;	// binary 15
+	var n4 = 0o7777;	// octal 4095
+	var n5 = 3.1415;	// real 3.1415
+	return n1+n2+n3+n4+n5;
+}

test/unittest/04-codegen/multiple_call.gravity

@@ -0,0 +1,15 @@
+#unittest {
+	name: "Test multiple call.";
+	error: NONE;
+	result: 123;
+};
+
+func f1() {return 123;}
+func f2() {return f1;}
+func f3() {return f2;}
+func f4() {return f3;}
+func f5() {return f4;}
+
+func main() {
+	return f5()()()()();
+}

test/unittest/04-codegen/var_default.gravity

@@ -0,0 +1,10 @@
+#unittest {
+	name: "Test local variable default value.";
+	error: NONE;
+	result: null;
+};
+
+func main() {
+	var a;
+	return a;
+}

test/unittest/arg_expression.gravity

@@ -0,0 +1,17 @@
+#unittest {
+	name: "_args used in expression.";
+	error: NONE;
+	result: 640;
+};
+
+func sum() {
+	var tot = 0;
+	_args.loop(func (value) {tot +=value});
+	return tot;
+}
+
+func main() {
+	var a = 10;
+	var b = 20;
+	return sum(a, b, a*(a+b+9)+(b-a), a, a*b)
+}

test/unittest/arguments_1.gravity

@@ -0,0 +1,13 @@
+#unittest {
+	name: "Test arguments keyword.";
+	error: NONE;
+	result: 100;
+};
+
+func sum (a,b,c) {
+	return _args[-1];
+}
+
+func main() {
+	return sum(10,20,30,40,50,60,70,80,90,100);
+}

test/unittest/arguments_2.gravity

@@ -0,0 +1,13 @@
+#unittest {
+	name: "Test arguments keyword.";
+	error: NONE;
+	result: 10;
+};
+
+func sum (a,b,c) {
+	return _args.count;
+}
+
+func main() {
+	return sum(10,20,30,40,50,60,70,80,90,100);
+}

test/unittest/arguments_sum.gravity

@@ -0,0 +1,17 @@
+#unittest {
+	name: "Test arguments keyword.";
+	error: NONE;
+	result: 550;
+};
+
+func sum () {
+	var tot = 0;
+	for (var i in 0..<_args.count) {
+		tot += _args[i];
+	}
+	return tot;
+}
+
+func main() {
+	return sum(10,20,30,40,50,60,70,80,90,100);
+}

test/unittest/array2string.gravity

@@ -0,0 +1,9 @@
+#unittest {
+	name: "List to string conversion test.";
+	result: "[1,2,3,34,marco,pippo]";
+};
+
+func main() {
+	var r = [1,2,3,34,"marco","pippo"];
+	return r.String();
+}

test/unittest/array_of_objects.gravity

@@ -0,0 +1,21 @@
+#unittest {
+	name: "Array of objects.";
+	result: 20;
+};
+
+class c1 {
+	var a = 10;
+}
+
+class c2 {
+	var a = 20;
+}
+
+class c3 {
+	var a = 30;
+}
+
+func main() {
+	var r = [c1(), c2(), c3()];
+	return r[1].a;
+}

test/unittest/base_class_override.gravity

@@ -0,0 +1,26 @@
+#unittest {
+	name: "Base class override.";
+	result: 1010;
+};
+
+class Rect {
+	var x,y,w,h;
+	
+	func init (n1,n2,n3,n4) {
+		x = n1;
+		y = n2;
+		w = n3;
+		h = n4;
+	}
+	
+	func Int() {
+		return x+y+w+h;
+	}
+}
+
+
+func main() {
+	var a = 10;
+	var b = Rect(100,200,300,400);
+	return a + b;
+}

test/unittest/base_exec.gravity

@@ -0,0 +1,16 @@
+#unittest {
+	name: "Base class execution.";
+	error: NONE;
+	result: true;
+};
+
+func main() {
+    var a = Int("32") == 32;
+    var b = String(34) == "34";
+    var c = Bool(4) == true;
+    var d = Null(33) == null;
+    var e = Float("2.23") == 2.23;
+    var f = Range(10,20) == (10...20);
+    
+    return a && b && c && d && e && f;
+}

test/unittest/big_list_map.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "Big list/map.";
+	error: NONE;
+	result: 275;
+};
+
+func main() {
+	// MAX_FIELDSxFLUSH set to 64
+	var a1 = [1,2,3];
+	var a2 = [1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,10,20,30,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,10,20,30,666];
+	var a3 = ["k1":1,"k2":2,"k3":3,"k4":4,"k5":5,"k6":6,"k7":7,"k8":8,"k9":9];
+	
+	return a1.count + a2.count + a3.count;
+}

test/unittest/bind.gravity

@@ -0,0 +1,27 @@
+#unittest {
+	name: "Bind/unbind test.";
+	error: NONE;
+	result: 61010;
+};
+
+class foo {
+	func f1() {return 10;}
+}
+
+func main() {
+	var obj = foo();
+	var n1 = obj.f1();				// 10
+	
+	func test() {return 1000;}
+	obj.bind("f2", test);
+	var n2 = obj.f2();				// 1000
+	
+	obj.bind("f3", {return 10000;});
+	var n3 = obj.f3();				// 10000
+	
+	obj.unbind("f2");
+	obj.bind("f2", {return 50000;});
+	var n4 = obj.f2();				// 50000
+	
+	return n1+n2+n3+n4;
+}

test/unittest/bitwise_on_bool.gravity

@@ -0,0 +1,37 @@
+#unittest {
+	name: "Bitwise and on a bool";
+	error: NONE;
+	result: true;
+};
+
+func b_and() {
+	var bool_ff = false & false; // false
+	var bool_tf = true  & false; // false
+	var bool_ft = false & true;  // false
+	var bool_tt = true  & true;  // true
+
+	return !bool_ff && !bool_tf && !bool_ft && bool_tt;
+}
+
+func b_or() {
+	var bool_ff = false | false; // false
+	var bool_tf = true  | false; // true
+	var bool_ft = false | true;  // true
+	var bool_tt = true  | true;  // true
+
+	return !bool_ff && bool_tf && bool_ft && bool_tt;
+}
+
+func b_xor() {
+	var bool_ff = false ^ false; // false
+	var bool_tf = true  ^ false; // true
+	var bool_ft = false ^ true;  // true
+	var bool_tt = true  ^ true;  // false
+
+	return !bool_ff && bool_tf && bool_ft && !bool_tt;
+}
+
+func main() {
+	return b_and() && b_or() && b_xor();
+}
+

test/unittest/chained_call.gravity

@@ -0,0 +1,18 @@
+#unittest {
+	name: "Chained call.";
+	result: 20;
+};
+
+func f1() {
+	return 10;
+}
+
+func f2() {
+	return f1;
+}
+
+func main() {
+	var a = f2;				// a is now function f2
+	var b = a();			// b is now return value of f2 which is function f1
+	return b() + f2()();	// return value is f1() which is 10
+}

test/unittest/chained_call2.gravity

@@ -0,0 +1,33 @@
+#unittest {
+	name: "Chained call 2.";
+	result: 2468;
+};
+
+func foo(a) {
+	return a*2;
+}
+
+class c3 {
+	var p1 = 555;
+	func init() {
+		p1 = foo;
+	}
+}
+
+class c2 {
+	var p1 = 333;
+	func init() {
+		p1 = c3();
+	}
+}
+
+class c1 {
+	var p1 = 111;
+	func init() {
+		p1 = c2();
+	}
+}
+
+func main() {
+	return c1().p1.p1.p1(1234);
+}

test/unittest/chained_call3.gravity

@@ -0,0 +1,36 @@
+#unittest {
+	name: "Chained call 3.";
+	result: 2468;
+};
+
+func foo(a) {
+	return a*2;
+}
+
+class c3 {
+	var p1 = 555;
+	func f1() {
+		p1 = 666;
+		return foo;
+	}
+}
+
+class c2 {
+	var p1 = 333;
+	func f1() {
+		p1 = 444;
+		return c3();
+	}
+}
+
+class c1 {
+	var p1 = 111;
+	func f1() {
+		p1 = 222;
+		return c2();
+	}
+}
+
+func main() {
+	return c1().f1().f1().f1()(1234);
+}

test/unittest/chained_call4.gravity

@@ -0,0 +1,17 @@
+#unittest {
+	name: "Chained call 4.";
+	result: 150;
+};
+
+class c1 {
+	var p1;
+	func f1() {
+		p1 = 150;
+		return p1;
+	}
+}
+
+func main() {
+	var x1 = c1().f1();
+	return x1;
+}

test/unittest/chained_call5.gravity

@@ -0,0 +1,27 @@
+#unittest {
+	name: "Class with no init.";
+	result: 200;
+};
+
+// no init
+class c1 {
+	var p1;
+	func f1() {
+		self.p1 = 150;
+		return self.p1;
+	}
+}
+
+class c2 {
+	var p1;
+	func f1() {
+		p1 = 50;
+		return p1;
+	}
+}
+
+
+func main() {
+	var x1 = c1().f1() + c2().f1();
+	return x1;
+}

test/unittest/class_byref.gravity

@@ -0,0 +1,17 @@
+#unittest {
+	name: "Class by ref.";
+	result: 120;
+};
+
+class Point {
+	public var x = 10;
+	public var y = 20;
+	public func sum() {return x+y;}
+}
+
+func main() {
+	var p1 = Point();
+	var p2 = p1;
+	p1.x = 50;
+	return p2.x + p1.sum();
+}

test/unittest/class_static.gravity

@@ -0,0 +1,17 @@
+#unittest {
+	name: "Test class static access.";
+	error: NONE;
+	result: 20;
+};
+
+class foo {
+	static var a;
+	static func p(p) {
+		a = [0,10,20,30];
+	}
+}
+
+func main() {
+	foo.p(5);
+	return foo.a[2];
+}

test/unittest/class_static_nonstatic.gravity

@@ -0,0 +1,38 @@
+#unittest {
+	name: "Test class static non static internal init.";
+	error: NONE;
+	result: 10890000;
+};
+
+// class declarations
+class bar {
+	// class var
+	static var a1 = 10;
+	static var a2 = 20;
+	
+	// class const
+	static var b1 = 100;
+	static var b2 = 200;
+	
+	// instance var
+	var c1 = 1000;
+	var c2 = 2000;
+	
+	// instance const
+	var d1 = 10000;
+	var d2 = 20000;
+	
+	static func f1() {
+		return a1+a2+b1+b2;
+	}
+	
+	func f2() {
+		return c1+c2+d1+d2;
+	}
+}
+
+func main() {
+	var n1 = bar.f1();		// 330
+	var n2 = bar().f2();	// 33000
+	return n1*n2;
+}

test/unittest/classes/add_operation_and_function_calls.gravity

@@ -0,0 +1,14 @@
+#unittest {
+	name: "ADD operation and function calls;";
+	error: NONE;
+	result: "classname: (bar)";
+};
+
+class foo {}
+class bar:foo {}
+
+func main() {
+	var v = bar();
+	var log = "classname: (" + v.Class().name() + ")";
+	return log;
+}

test/unittest/classes/base_object_methods.gravity

@@ -0,0 +1,41 @@
+#unittest {
+	name: "Basic object methods;";
+	error: NONE;
+	result: true;
+};
+
+class foo {}
+class bar:foo {}
+
+func main() {
+	var r;
+	
+	r = bar.name();
+	if (r != "bar") return "-1 (" + r + ")";
+	
+	r = bar.Class().name();
+	if (r != "bar meta") return "-2 (" + r + ")";
+	
+	func echo(v) {return v;}
+	r = echo.Class().name();
+	if (r != "Closure") return "-3 (" + r + ")";
+	
+	var instance = bar();
+	r = instance.Class().name();
+	if (r != "bar") return "-4 (" + r + ")";
+	
+	r = instance.Class().Class().Class().name();
+	if (r != "bar meta") return "-5 (" + r + ")";
+	
+	var v = "A string";
+	var log;
+	
+	r = v.String();					if (r != v)			return "-7 (" + r + ")";
+	r = bar.String();				if (r != "bar")		return "-9 (" + r + ")";
+	r = 0.1.String();				if (r != "0.100000")	return "-10 (" + r + ")";
+	r = null.String();				if (r != "null")	return "-11 (" + r + ")";
+	r = true.String();				if (r != "true")	return "-12 (" + r + ")";
+	r = main.String();				if (r != "main")	return "-13 (" + r + ")";
+	
+	return true;
+}

test/unittest/classes/classes_0.gravity

@@ -0,0 +1,19 @@
+#unittest {
+	name: "Subclass with overridden method.";
+	error: NONE;
+	result: 12;
+};
+
+class foo {
+	func f1() {return 1;}
+}
+
+class bar:foo {
+	func f1() {return 10;}
+	func f2() {return 2;}
+}
+
+func main() {
+	var obj1 = bar();
+	return obj1.f1() + obj1.f2();
+}

test/unittest/classes/classes_1.gravity

@@ -0,0 +1,35 @@
+#unittest {
+	name: "Type names.";
+	error: NONE;
+	result: true;
+};
+
+class foo {
+	func f1() {return 1000;}
+}
+
+class bar:foo {
+	func f1() {return 10;}
+	func f2() {return 2000;}
+}
+
+func main() {
+	var a = 1;
+	var b = 2.2;
+	var c = true;
+	var d = "Marco";
+	var e = null;
+	var f = bar();
+	
+	var r;
+	
+	r = bar.Class().name();	if (r != "bar meta")	return "-1: " + r.String();
+	r = a.Class().name();	if (r != "Int")			return "-2: " + r.String();
+	r = b.Class().name();	if (r != "Float")		return "-3: " + r.String();
+	r = c.Class().name();	if (r != "Bool")		return "-4: " + r.String();
+	r = d.Class().name();	if (r != "String")		return "-5: " + r.String();
+	r = e.Class().name();	if (r != "Null")		return "-6: " + r.String();
+	r = f.Class().name();	if (r != "bar")			return "-7: " + r.String();
+	
+	return true;
+}

test/unittest/classes/classes_2.gravity

@@ -0,0 +1,39 @@
+#unittest {
+	name: "Playing with class' init function;";
+	error: FALSE;
+	result: true;
+};
+
+class foo {
+	func f1() {return 1;}
+}
+
+class bar:foo {
+	var a;
+	func init(val) {
+		a = val;
+	}
+	func f1() {return 1 * a;}
+	func f2() {return 2 * a;}
+}
+
+func main() {
+	var f1 = foo();
+	var b1 = bar(0);
+	var b2 = bar(4);
+	var b3 = bar("1-string");
+	var r;
+	
+	r = b1.f1();	if (r != 0)		return "-1 (" + r + ")";
+	r = b2.f1();	if (r != 4)		return "-2 (" + r + ")";
+	r = b3.f1();	if (r != 1)		return "-3 (" + r + ")";
+	
+	b3.init(2);
+	r = b3.f1();	if (r != 2)		return "-4 (" + r + ")";
+	
+	b3.init(4).init(8);
+	r = b3.f1();
+	if (r != 8)		return "-5 (" + r + ")";
+	
+	return true;
+}

test/unittest/classes/test_classes.gravity

@@ -0,0 +1,54 @@
+#unittest {
+	name: "Test classes with both static and non static members.";
+	error: NONE;
+	result: 9999;
+};
+
+// nothing
+class c0 {
+	func sum() {
+		var a = 1, b=2, c=3;
+		return a + b + c;
+	}
+}
+
+// constructor only
+class c1 {
+	var a;
+	var b;
+	var c;
+	func init() {a = 10; b = 20; c = 30;}
+	func sum() {return a + b + c;}
+}
+
+// init special only
+class c2 {
+	var a = 100;
+	var b = 200;
+	var c = 300;
+	func sum() {return a + b + c;}
+}
+
+// both init special and constructor
+class c3 {
+	var a = 1000;
+	var b;
+	var c;
+	func init() {b = 2000; c = 3000;}
+	func sum() {return a + b + c;}
+}
+
+// mixed static and non static
+class c4 {
+	static func sum1(){return 1111;}
+	func sum2(){return 2222;}
+}
+
+func main() {
+	var obj0 = c0();
+	var obj1 = c1();
+	var obj2 = c2();
+	var obj3 = c3();
+	var obj4 = c4();
+	return obj0.sum() + obj1.sum() + obj2.sum() + obj3.sum() + obj4.sum2() + c4.sum1();
+}

test/unittest/classes/test_declarations.gravity

@@ -0,0 +1,33 @@
+#unittest {
+	name: "Test classes declaration with both static and non static members.";
+	error: NONE;
+	result: 100;
+};
+
+// global declarations
+var a;
+var b = 10;
+var c = func() {return 20;};
+
+// class declarations
+class bar {
+	var a = 10;
+	static func b() {return 20;}
+	func c() {return a;}
+}
+
+// function declarations
+func foo() {
+	var a = 0;
+	var b = 10;
+	var c = func() {return 20;};
+	return a + b + c();
+}
+
+// test
+func main() {
+	var ref = bar;
+	var obj1 = ref();
+	var obj2 = bar();
+	return a + b + c() + foo() + bar.b() + obj1.c()+ obj2.c();
+}

test/unittest/closure.gravity

@@ -0,0 +1,16 @@
+#unittest {
+	name: "Simple closure.";
+	error: NONE;
+	result: 30;
+};
+
+func f1(a) {
+	return func(b) {
+		return a + b;
+	}
+}
+
+func main() {
+	var addTen = f1(10);
+	return addTen(20);
+}

test/unittest/closure2.gravity

@@ -0,0 +1,19 @@
+#unittest {
+	name: "Upvalue closure.";
+	error: NONE;
+	result: 230;
+};
+
+func f1(a) {
+	return func(b) {
+		return func (c) {
+			return c + b * a;
+		}
+	}
+}
+
+func main() {
+	var f = f1(10);
+	var f2 = f(20)(30);
+	return f2;
+}

test/unittest/closure3.gravity

@@ -0,0 +1,26 @@
+#unittest {
+	name: "Complex nested closures.";
+	error: NONE;
+	result: 2290;
+};
+
+func f1(a) {
+	return func(b) {
+		return func (c) {
+			return func (d) {
+				return func (e) {
+					return func (f) {
+						return c + b * a + (d * e + f);
+					}
+				}
+			}
+		}
+	}
+}
+
+func main() {
+	var f = f1(10);
+	var f2 = f(20)(30);
+	var f3 = f2(40)(50)(60);
+	return f3;
+}

test/unittest/closure_apply.gravity

@@ -0,0 +1,13 @@
+#unittest {
+	name: "Simple closure.apply";
+	error: NONE;
+	result: 3;
+};
+
+func add(a,b) {
+	return a + b;
+}
+
+func main() {
+	return add.apply(self, [1,2]);
+}

test/unittest/closure_args_apply.gravity

@@ -0,0 +1,13 @@
+#unittest {
+	name: "Simple closure.apply with _args.";
+	error: NONE;
+	result: 3;
+};
+
+func add() {
+	return _args[0] + _args[1];
+}
+
+func main() {
+	return add.apply(self, [1,2]);
+}

test/unittest/computed_properties.gravity

@@ -0,0 +1,18 @@
+#unittest {
+	name: "Computed properties.";
+	result: 700;
+};
+
+class foo {
+	private var _a = 12;
+	var a {
+		set {_a = value * 100;}
+		get {return _a/2;}
+	};
+}
+
+func main() {
+	var f = foo();
+	f.a = 14;		// 14*100 = 1400
+	return f.a;		// 1400/2 = 700
+}

test/unittest/conversion/conversion_bool.gravity

@@ -0,0 +1,31 @@
+#unittest {
+	name: "Conversion to Bool;";
+	error: NONE;
+	result: true;
+};
+
+func main() {
+	var v,r;
+	
+	v = "str";
+	r = v.Bool();		if (r != true)		return "-1 (" + r + ")";
+	r = "str".Bool();	if (r != true)		return "-2 (" + r + ")";
+	
+	v = null;
+	r = v.Bool();		if (r != false)		return "-3 (" + r + ")";
+	r = null.Bool();	if (r != false)		return "-4 (" + r + ")";
+	
+	v = true;
+	r = v.Bool();		if (r != true)		return "-5 (" + r + ")";
+	r = true.Bool();	if (r != true)		return "-6 (" + r + ")";
+	
+	v = 6;
+	r = v.Bool();		if (r != true)		return "-7 (" + r + ")";
+	r = 6.Bool();		if (r != true)		return "-8 (" + r + ")";
+	
+	v = 1.1;
+	r = v.Bool();		if (r != true)		return "-9 (" + r + ")";
+	r = 1.1.Bool();		if (r != true)		return "-10 (" + r + ")";
+	
+	return true;
+}

test/unittest/conversion/conversion_float.gravity

@@ -0,0 +1,31 @@
+#unittest {
+	name: "Conversion to Float;";
+	error: NONE;
+	result: true;
+};
+
+func main() {
+	var v,r;
+	
+	v = "1.1str";
+	r = v.Float();			if (r != 1.1)	return "-1 (" + r + ")";
+	r = "1.1str".Float();	if (r != 1.1)	return "-2 (" + r + ")";
+	
+	v = null;
+	r = v.Float();			if (r != 0)		return "-3 (" + r + ")";
+	r = null.Float();		if (r != 0)		return "-4 (" + r + ")";
+	
+	v = true;
+	r = v.Float();			if (r != 1)		return "-5 (" + r + ")";
+	r = true.Float();		if (r != 1)		return "-6 (" + r + ")";
+	
+	v = 6;
+	r = v.Float();			if (r != 6)		return "-7 (" + r + ")";
+	r = 6.Float();			if (r != 6)		return "-8 (" + r + ")";
+	
+	v = 1.1;
+	r = v.Float();			if (r != 1.1)	return "-9 (" + r + ")";
+	r = 1.1.Float();		if (r != 1.1)	return "-10 (" + r + ")";
+	
+	return true;
+}

test/unittest/conversion/conversion_int.gravity

@@ -0,0 +1,31 @@
+#unittest {
+	name: "Conversion to Int;";
+	error: NONE;
+	result: true;
+};
+
+func main() {
+	var v,r;
+	
+	v = "2bstr";
+	r = v.Int();		if (r != 2)			return "-1 (" + r + ")";
+	r = "2bstr".Int();	if (r != 2)			return "-2 (" + r + ")";
+	
+	v = null;
+	r = v.Int();		if (r != 0)			return "-3 (" + r + ")";
+	r = null.Int();		if (r != 0)			return "-4 (" + r + ")";
+	
+	v = true;
+	r = v.Int();		if (r != 1)			return "-5 (" + r + ")";
+	r = true.Int();		if (r != 1)			return "-6 (" + r + ")";
+	
+	v = 6;
+	r = v.Int();		if (r != 6)			return "-7 (" + r + ")";
+	r = 6.Int();		if (r != 6)			return "-8 (" + r + ")";
+	
+	v = 1.1;
+	r = v.Int();		if (r != 1)			return "-9 (" + r + ")";
+	r = 1.1.Int();		if (r != 1)			return "-10 (" + r + ")";
+	
+	return true;
+}