More tests and fixes; anon ref/set/list.

6 files changed, 408 insertions, 24 deletions

diff --git a/data/tests/collections.fate b/data/tests/collections.fate
new file mode 100644
index 0000000..0c804bd
--- /dev/null
+++ b/data/tests/collections.fate
@@ -0,0 +1,151 @@
+(fate_version 1)
+
+(require include/data_types.fate)
+
+(declare_variable int_list int_list_a)
+(declare_variable int_list int_list_b)
+(declare_variable int_list int_list_c)
+
+(declare_variable int_set int_set_a)
+(declare_variable int_set int_set_b)
+(declare_variable int_set int_set_c)
+
+(assert (= 0 (size (var int_list_a))) FAILED: size list A)
+(assert (= 0 (size (var int_set_a))) FAILED: size set A)
+
+(add_element 3 int_list_a)
+(add_element 3 int_set_a)
+(assert (= 1 (size (var int_list_a))) FAILED: size list B)
+(assert (= 1 (size (var int_set_a))) FAILED: size set B)
+
+(add_element 3 int_list_a)
+(add_element 3 int_set_a)
+(assert (= 2 (size (var int_list_a))) FAILED: size list C)
+(assert (= 1 (size (var int_set_a))) FAILED: size set C)
+
+(remove_one 3 int_list_a)
+(remove_one 3 int_set_a)
+(assert (= 1 (size (var int_list_a))) FAILED: size list D)
+(assert (= 0 (size (var int_set_a))) FAILED: size set D)
+
+(remove_one 3 int_list_a)
+(remove_one 3 int_set_a)
+(assert (= 0 (size (var int_list_a))) FAILED: size list E)
+(assert (= 0 (size (var int_set_a))) FAILED: size set E)
+
+(remove_one 3 int_list_a)
+(remove_one 3 int_set_a)
+(assert (= 0 (size (var int_list_a))) FAILED: size list F)
+(assert (= 0 (size (var int_set_a))) FAILED: size set F)
+
+(add 1 int_list_a)
+(add 2 int_list_a)
+(add 3 int_list_a)
+(add 4 int_list_a)
+(add 5 int_list_a)
+(add 6 int_list_a)
+(add 7 int_list_a)
+(add 8 int_list_a)
+(add 9 int_list_a)
+(add 10 int_list_a)
+
+(add 3 int_set_a)
+(add 5 int_set_a)
+(add 2 int_set_a)
+(add 8 int_set_a)
+(add 4 int_set_a)
+(add 6 int_set_a)
+(add 10 int_set_a)
+(add 1 int_set_a)
+(add 9 int_set_a)
+(add 7 int_set_a)
+
+(add 3 int_set_a)
+(add 5 int_set_a)
+(add 2 int_set_a)
+(add 8 int_set_a)
+(add 4 int_set_a)
+(add 6 int_set_a)
+(add 10 int_set_a)
+(add 1 int_set_a)
+(add 9 int_set_a)
+(add 7 int_set_a)
+
+(assert (= 10 (size (var int_list_a))) FAILED: size list G)
+(assert (= 10 (size (var int_set_a))) FAILED: size set G)
+
+(add 1 int_list_a)
+(add 2 int_list_a)
+(add 3 int_list_a)
+(add 4 int_list_a)
+(add 5 int_list_a)
+(add 6 int_list_a)
+(add 7 int_list_a)
+(add 8 int_list_a)
+(add 9 int_list_a)
+(add 10 int_list_a)
+
+(assert (= 20 (size (var int_list_a))) FAILED: size list H)
+
+(remove_all 4 int_list_a)
+
+(assert (= 18 (size (var int_list_a))) FAILED: size list I)
+
+(remove_element_at 0 int_list_a)
+(assert (= 17 (size (var int_list_a))) FAILED: size list J)
+
+(remove_all 1 int_list_a)
+(assert (= 16 (size (var int_list_a))) FAILED: size list K)
+
+(clear int_list_a)
+(clear int_set_a)
+(assert (= 0 (size (var int_list_a))) FAILED: size list L)
+(assert (= 0 (size (var int_set_a))) FAILED: size set L)
+
+(add 1 int_list_a)
+(add 2 int_list_a)
+(add 3 int_list_a)
+(add 4 int_list_a)
+(add 5 int_list_a)
+(add 6 int_list_a)
+(add 7 int_list_a)
+(add 8 int_list_a)
+(add 9 int_list_a)
+(add 10 int_list_a)
+(add 10 int_list_a)
+(add 9 int_list_a)
+(add 8 int_list_a)
+(add 7 int_list_a)
+(add 6 int_list_a)
+(add 5 int_list_a)
+(add 4 int_list_a)
+(add 3 int_list_a)
+(add 2 int_list_a)
+(add 1 int_list_a)
+
+(remove_at 0 int_list_a)
+(reverse int_list_a)
+(remove_at 0 int_list_a)
+
+(add 1 int_list_b)
+(add 2 int_list_b)
+(add 3 int_list_b)
+(add 4 int_list_b)
+(reverse int_list_b)
+
+(assert (= 18 (size (var int_list_a))) FAILED: size list M)
+
+(remove_all 1 int_list_a)
+
+(assert (= 18 (size (var int_list_a))) FAILED: size list N)
+
+(assert (= 2 (access int_list_a 0)) FAILED: size list M_BIS (access int_list_a 0))
+(assert (= 5 (access int_list_a 3)) FAILED: size list N_BIS (access int_list_a 3))
+(assert (= 2 (count 10 int_list_a)) FAILED: size list O)
+(assert (= 0 (count 99 int_list_a)) FAILED: size list P)
+;;(assert (= 0 (index_of 2 int_list_a)) FAILED: size list Q)
+;;(assert (= 1 (index_of 3 int_list_a)) FAILED: size list R)
+(assert (not (is_member 99 int_list_a)) FAILED: size list S)
+(assert (is_member 10 int_list_a) FAILED: size list T)
+
+(end)
diff --git a/data/tests/comparisons.fate b/data/tests/comparisons.fate
new file mode 100644
index 0000000..68c5ed9
--- /dev/null
+++ b/data/tests/comparisons.fate
@@ -0,0 +1,48 @@
+(fate_version 1)
+
+(assert (exactly_one (< a b) (< b a)) FAILED: string comparison A)
+(assert (exactly_one (< a aa) (< aa a)) FAILED: string comparison B)
+
+(assert
+   (exactly_one (< ( a aa ) ( aa a )) (< ( aa a ) ( a aa )))
+   FAILED: string comparison C
+)
+
+(declare_ptr_type int int_ptr)
+
+(def_var int i)
+(def_var int_ptr i_ptr)
+
+(def_var int j)
+(def_var int_ptr j_ptr)
+
+(set i_ptr (ptr i))
+(set j_ptr (ptr j))
+
+(assert (exactly_one
+      (< (var i_ptr) (var j_ptr))
+      (< (var j_ptr) (var i_ptr))
+   )
+   FAILED: string comparison C
+)
+
+(def_dict test_dict_t
+   (int a)
+   (int b)
+)
+
+(def_var test_dict_t td)
+
+(set i_ptr (ptr td.a))
+(set j_ptr (ptr td.b))
+
+
+(assert
+   (exactly_one
+      (< (var i_ptr) (var j_ptr))
+      (< (var j_ptr) (var i_ptr))
+   )
+   FAILED: string comparison D
+)
+
+(end)
diff --git a/data/tests/include/data_types.fate b/data/tests/include/data_types.fate
index 3205b69..abffedb 100644
--- a/data/tests/include/data_types.fate
+++ b/data/tests/include/data_types.fate
@@ -20,33 +20,33 @@
 (typedef sub_string sub_sub_string)
 (typedef sub_string alt_sub_string)
 
-(define_list_type boolean list_boolean)
-(define_list_type sub_boolean list_sub_boolean)
-(define_set_type boolean set_boolean)
-(define_set_type sub_boolean set_sub_boolean)
-(define_ref_type boolean ref_boolean)
-(define_ref_type sub_boolean ref_sub_boolean)
+(define_list_type boolean boolean_list)
+(define_list_type sub_boolean sub_boolean_list)
+(define_set_type boolean boolean_set)
+(define_set_type sub_boolean sub_boolean_set)
+(define_ref_type boolean boolean_ptr)
+(define_ref_type sub_boolean sub_boolean_ptr)
 
-(define_list_type int list_int)
-(define_list_type sub_int list_sub_int)
-(define_set_type int set_int)
-(define_set_type sub_int set_sub_int)
-(define_ref_type int ref_int)
-(define_ref_type sub_int ref_sub_int)
+(define_list_type int int_list)
+(define_list_type sub_int sub_int_list)
+(define_set_type int int_set)
+(define_set_type sub_int sub_int_set)
+(define_ref_type int int_ptr)
+(define_ref_type sub_int sub_int_ptr)
 
-(define_list_type float list_float)
-(define_list_type sub_float list_sub_float)
-(define_set_type float set_float)
-(define_set_type sub_float set_sub_float)
-(define_ref_type float ref_float)
-(define_ref_type sub_float ref_sub_float)
+(define_list_type float float_list)
+(define_list_type sub_float sub_float_list)
+(define_set_type float float_set)
+(define_set_type sub_float sub_float_set)
+(define_ref_type float float_ptr)
+(define_ref_type sub_float sub_float_ptr)
 
-(define_list_type string list_int)
-(define_list_type sub_string list_sub_int)
-(define_set_type string set_int)
-(define_set_type sub_string set_sub_int)
-(define_ref_type string ref_int)
-(define_ref_type sub_string ref_sub_int)
+(define_list_type string string_list)
+(define_list_type sub_string sub_string_list)
+(define_set_type string string_set)
+(define_set_type sub_string sub_string_set)
+(define_ref_type string string_ptr)
+(define_ref_type sub_string sub_string_ptr)
 
 (define_dict_type simple_dict
    (boolean boolean)
diff --git a/data/tests/locales.fate b/data/tests/locales.fate
new file mode 100644
index 0000000..21244d8
--- /dev/null
+++ b/data/tests/locales.fate
@@ -0,0 +1,19 @@
+(fate_version 1)
+
+大野！私はこれらの言語を話せません！
+
+(declare_variable int 変数)
+
+(for (set 変数 0) (< (var 変数) 10) (set 変数 (+ (var 変数) 1))
+   私は数を使って数えることができます：(var 変数)
+)
+
+أوه لا! أنا لا أتحدث أيًا من هذه اللغات!
+
+(declare_variable int ﻢﺘﻐﻳﺭ)
+
+(for (set ﻢﺘﻐﻳﺭ 0) (< (var ﻢﺘﻐﻳﺭ) 10) (set ﻢﺘﻐﻳﺭ (+ (var ﻢﺘﻐﻳﺭ) 1))
+   لا يهم. يمكنني فقط استخدام الأرقام للعد حتى: (var ﻢﺘﻐﻳﺭ)
+)
+
+(end)
diff --git a/data/tests/loops.fate b/data/tests/loops.fate
new file mode 100644
index 0000000..db7f212
--- /dev/null
+++ b/data/tests/loops.fate
@@ -0,0 +1,149 @@
+(fate_version 1)
+
+(require include/data_types.fate)
+
+(declare_variable int i)
+(declare_variable int test_val)
+(declare_variable int test_val2)
+
+(set test_val 0)
+(set test_val2 0)
+
+(for (set i 0) (< (var i) 10) (set i (+ (var i) 1))
+   (set test_val (+ (var test_val) 1))
+   (set test_val2 (+ (var test_val2) 1))
+)
+
+(assert (= (var test_val) 10) FAILED: for loop A)
+(assert (= (var test_val2) 10) FAILED: for loop B)
+(assert (= (var i) 10) FAILED: for loop C)
+
+(set i 0)
+
+(set test_val 0)
+(set test_val2 0)
+
+(while (< (var i) 10)
+   (set test_val (+ (var test_val) 1))
+   (set test_val2 (+ (var test_val2) 1))
+   (set i (+ (var i) 1))
+)
+
+(assert (= (var test_val) 10) FAILED: while loop A)
+(assert (= (var test_val2) 10) FAILED: while loop B)
+(assert (= (var i) 10) FAILED: while loop C)
+
+(set i 0)
+
+(set test_val 0)
+(set test_val2 0)
+
+(do_while (< (var i) 10)
+   (set test_val (+ (var test_val) 1))
+   (set test_val2 (+ (var test_val2) 1))
+   (set i (+ (var i) 1))
+)
+
+(assert (= (var test_val) 10) FAILED: do while loop A)
+(assert (= (var test_val2) 10) FAILED: do while loop B)
+(assert (= (var i) 10) FAILED: do while loop C)
+
+(set i 0)
+(set test_val 0)
+(set test_val2 0)
+
+(do_while (false)
+   (set test_val (+ (var test_val) 1))
+   (set test_val2 (+ (var test_val2) 1))
+   (set i (+ (var i) 1))
+)
+
+(assert (= (var test_val) 1) FAILED: do while loop D)
+(assert (= (var test_val2) 1) FAILED: do while loop E)
+(assert (= (var i) 1) FAILED: do while loop F)
+
+(declare_variable int_list int_list_a)
+(declare_variable int_list int_list_b)
+
+(for (set i 0) (< (var i) 10) (set i (+ (var i) 1))
+   (add_element 1 int_list_a)
+   (add_element 1 int_list_b)
+)
+
+(set test_val 0)
+(set test_val2 0)
+
+(foreach int_list_a a
+   (set test_val (+ (var test_val) (param a)))
+   (set test_val2 (+ (var test_val2) (param a)))
+)
+(assert (= (var test_val) 10) FAILED: for each loop A)
+(assert (= (var test_val2) 10) FAILED: for each loop B)
+
+
+(set test_val 0)
+(set test_val2 0)
+
+(for (set i 0) (< (var i) 10) (set i (+ (var i) 1))
+   (set test_val (+ (var test_val) 1))
+   (break)
+   (set test_val2 (+ (var test_val2) 1))
+)
+(assert (= (var test_val) 1) FAILED: break loop A)
+(assert (= (var test_val2) 0) FAILED: for each loop B)
+
+(set i 0)
+
+(set test_val 0)
+(set test_val2 0)
+
+(while (< (var i) 10)
+   (set test_val (+ (var test_val) 1))
+   (break)
+   (set test_val2 (+ (var test_val2) 1))
+   (set i (+ (var i) 1))
+)
+(assert (= (var test_val) 1) FAILED: break while loop A)
+(assert (= (var test_val2) 0) FAILED: break while loop B)
+(assert (= (var i) 0) FAILED: break while loop C)
+
+(set i 0)
+
+(set test_val 0)
+(set test_val2 0)
+
+(do_while (< (var i) 10)
+   (set test_val (+ (var test_val) 1))
+   (break)
+   (set test_val2 (+ (var test_val2) 1))
+   (set i (+ (var i) 1))
+)
+(assert (= (var test_val) 1) FAILED: break do while loop A)
+(assert (= (var test_val2) 0) FAILED: break do while loop B)
+(assert (= (var i) 0) FAILED: break do while loop C)
+
+(set test_val 0)
+
+(foreach int_list_a a
+   (set test_val (+ (var test_val) (param a)))
+   (break)
+   (set test_val2 (+ (var test_val2) (param a)))
+)
+(assert (= (var test_val) 1) FAILED: break foreach loop A)
+(assert (= (var test_val2) 0) FAILED: break foreach loop B)
+
+(clear int_list_b)
+
+(foreach int_list_a a
+   (add_element (param a) int_list_b)
+   (for (set i 0) (< (var i) 1) (set i (+ (var i) 1))
+      (add_element (var i) int_list_b)
+   )
+   (do_while (< (var i) 10)
+      (break)
+   )
+)
+
+(assert (= (size int_list_b) (* 2 (size int_list_a))) FAILED: inner break)
+
+(end)
diff --git a/data/tests/references.fate b/data/tests/references.fate
new file mode 100644
index 0000000..cc30154
--- /dev/null
+++ b/data/tests/references.fate
@@ -0,0 +1,17 @@
+(fate_version 1)
+
+(require include/data_types.fate)
+
+(def_var (ptr int) alloc_i)
+
+(set alloc_i (new int))
+(set (at alloc_i) 2)
+
+(assert (= (at (var alloc_i)) 2) FAILED: set at A)
+
+(def_var (ptr (ptr int)) i_ptr_ptr)
+(set i_ptr_ptr (ptr alloc_i))
+(set (at (at i_ptr_ptr)) 4)
+(assert (= (at (var alloc_i)) 4) FAILED: set at B)
+
+(end)