summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--data/unit-testing/add_element.fate111
-rw-r--r--data/unit-testing/add_element_at.fate2
-rw-r--r--data/unit-testing/add_elements_of.fate62
-rw-r--r--data/unit-testing/cast.fate103
-rw-r--r--data/unit-testing/cond.fate179
-rw-r--r--data/unit-testing/cons_car_cdr.fate51
-rw-r--r--data/unit-testing/ptr_and_at.fate97
-rw-r--r--src/core/src/tonkadur/fate/v1/lang/computation/Cast.java80
8 files changed, 638 insertions, 47 deletions
diff --git a/data/unit-testing/add_element.fate b/data/unit-testing/add_element.fate
new file mode 100644
index 0000000..9e37a6a
--- /dev/null
+++ b/data/unit-testing/add_element.fate
@@ -0,0 +1,111 @@
+(fate_version 1)
+
+(global string test_name)
+
+(set test_name ( ADD ELEMENT ))
+
+(global (list int) li0)
+(global (list int) li1)
+
+(set li0 (add_element -1 li0))
+(set li0 (add_element 0 li0))
+(set li0 (add_element 1 li0))
+(set li0 (add_element 2 li0))
+(set li0 (add_element 3 li0))
+(set li0 (add_element 4 li0))
+(set li0 (add_element 5 li0))
+(set li0 (add_element 6 li0))
+
+(add_element! -1 li1)
+(add_element! 0 li1)
+(add_element! 1 li1)
+(add_element! 2 li1)
+(add_element! 3 li1)
+(add_element! 4 li1)
+(add_element! 5 li1)
+(add_element! 6 li1)
+
+(assert (= (var li0) (var li1)) [FAILED] (var test_name) equality.)
+
+(assert (= (var li0.0) (var li1.0) -1) [FAILED] (var test_name) at 0: (var li0.0), (var li1.0).)
+(assert (= (var li0.1) (var li1.1) 0) [FAILED] (var test_name) at 1: (var li0.1), (var li1.1).)
+(assert (= (var li0.2) (var li1.2) 1) [FAILED] (var test_name) at 2: (var li0.2), (var li1.2).)
+(assert (= (var li0.3) (var li1.3) 2) [FAILED] (var test_name) at 3: (var li0.3), (var li1.3).)
+(assert (= (var li0.4) (var li1.4) 3) [FAILED] (var test_name) at 4: (var li0.4), (var li1.4).)
+(assert (= (var li0.5) (var li1.5) 4) [FAILED] (var test_name) at 5: (var li0.5), (var li1.5).)
+(assert (= (var li0.6) (var li1.6) 5) [FAILED] (var test_name) at 6: (var li0.6), (var li1.6).)
+(assert (= (var li0.7) (var li1.7) 6) [FAILED] (var test_name) at 7: (var li0.7), (var li1.7).)
+
+(global (list int) ali0)
+(global (list int) ali1)
+
+(set ali0 (add_element 6 (range -1 5 1)))
+(set ali1
+ (add_element 6
+ (add_element 5
+ (add_element 4
+ (add_element 3
+ (add_element 2
+ (add_element 1
+ (add_element 0
+ (add_element -1 ali1)
+ )
+ )
+ )
+ )
+ )
+ )
+ )
+)
+
+(assert (= (var li0) (var li1) (var ali0) (var ali1)) [FAILED] (var test_name) equality 2.)
+
+(global (set int) si0)
+(global (set int) si1)
+(global (ptr (set int)) si_ptr)
+
+(set si_ptr (ptr si1))
+
+(set si0 (add_element 6 si0))
+(set si0 (add_element 0 si0))
+(set si0 (add_element 1 si0))
+(set si0 (add_element 4 si0))
+(set si0 (add_element -1 si0))
+(set si0 (add_element 5 si0))
+(set si0 (add_element 3 si0))
+(set si0 (add_element 2 si0))
+
+(add_element! 4 si1)
+(add_element! 0 (at (ptr si1)))
+(add_element! 3 si1)
+(add_element! -1 si1)
+(add_element! 2 si1)
+(add_element! 6 si1)
+(add_element! 1 (at si_ptr))
+(add_element! 5 si1)
+
+(assert (= (var li0) (var li1) (var ali0) (var ali1) (var si0) (var si1)) [FAILED] (var test_name) equality 3.)
+
+(set si0 (add_element 0 si0))
+(set si0 (add_element 4 si0))
+(set si0 (add_element 6 si0))
+(set si0 (add_element 5 si0))
+(set si0 (add_element 3 si0))
+(set si0 (add_element -1 si0))
+(set si0 (add_element 2 si0))
+(set si0 (add_element 1 si0))
+
+(add_element! 4 si1)
+(add_element! 1 si1)
+(add_element! 0 si1)
+(add_element! 6 si1)
+(add_element! -1 si1)
+(add_element! 3 si1)
+(add_element! 2 si1)
+(add_element! 5 si1)
+
+(assert (= (var li0) (var li1) (var ali0) (var ali1) (var si0) (var si1)) [FAILED] (var test_name) equality 4.)
+
+[COMPLETED] (var test_name)
+
+(end)
diff --git a/data/unit-testing/add_element_at.fate b/data/unit-testing/add_element_at.fate
index 97c0b3c..43e8b1e 100644
--- a/data/unit-testing/add_element_at.fate
+++ b/data/unit-testing/add_element_at.fate
@@ -34,7 +34,7 @@
(assert (= (var li0.4) (var li1.4) 0) [FAILED] (var test_name) at 4: (var li0.4), (var li1.4).)
(assert (= (var li0.5) (var li1.5) 1) [FAILED] (var test_name) at 5: (var li0.5), (var li1.5).)
(assert (= (var li0.6) (var li1.6) 2) [FAILED] (var test_name) at 6: (var li0.6), (var li1.6).)
-(assert (= (var li0.7) (var li1.7) 3) [FAILED] (var test_name) at 7: (var li0.6), (var li1.6).)
+(assert (= (var li0.7) (var li1.7) 3) [FAILED] (var test_name) at 7: (var li0.7), (var li1.7).)
[COMPLETED] (var test_name)
diff --git a/data/unit-testing/add_elements_of.fate b/data/unit-testing/add_elements_of.fate
new file mode 100644
index 0000000..1fead8a
--- /dev/null
+++ b/data/unit-testing/add_elements_of.fate
@@ -0,0 +1,62 @@
+(fate_version 1)
+
+(global string test_name)
+
+(set test_name ( ADD ELEMENTS OF ))
+
+(global (list int) li0)
+(global (list int) li1)
+
+(set li0
+ (add_all (range 8 10 1)
+ (add_all (range 4 7 1)
+ (add_all (range 0 3 1)
+ (default (list int))
+ )
+ )
+ )
+)
+
+(add_all! (range 0 3 1) li1)
+(add_all! (range 4 7 1) (at (ptr li1)))
+(add_all! (range 8 10 1) li1)
+
+(assert (= (var li0) (var li1)) [FAILED] (var test_name) equality.)
+
+(assert (= (var li0.0) (var li1.0) 0) [FAILED] (var test_name) at 0: (var li0.1), (var li1.0).)
+(assert (= (var li0.1) (var li1.1) 1) [FAILED] (var test_name) at 1: (var li0.1), (var li1.1).)
+(assert (= (var li0.2) (var li1.2) 2) [FAILED] (var test_name) at 2: (var li0.2), (var li1.2).)
+(assert (= (var li0.3) (var li1.3) 3) [FAILED] (var test_name) at 3: (var li0.3), (var li1.3).)
+(assert (= (var li0.4) (var li1.4) 4) [FAILED] (var test_name) at 4: (var li0.4), (var li1.4).)
+(assert (= (var li0.5) (var li1.5) 5) [FAILED] (var test_name) at 5: (var li0.5), (var li1.5).)
+(assert (= (var li0.6) (var li1.6) 6) [FAILED] (var test_name) at 6: (var li0.6), (var li1.6).)
+(assert (= (var li0.7) (var li1.7) 7) [FAILED] (var test_name) at 7: (var li0.7), (var li1.7).)
+
+(add_all! (range 11 20 1) li0)
+(add_all! (range 11 20 1) li1)
+
+(global (set int) si0)
+(global (set int) si1)
+
+(set si0
+ (add_all (range 0 10 2)
+ (add_all (range 11 20 2)
+ (add_all (range 1 10 2)
+ (add_all (range 12 20 2)
+ (default (set int))
+ )
+ )
+ )
+ )
+)
+
+(add_all! (range 0 10 2) si1)
+(add_all! (range 11 20 2) (at (ptr si1)))
+(add_all! (range 1 10 2) si1)
+(add_all! (range 12 20 2) si1)
+
+(assert (= (var li0) (var li1) (var si0) (var si1)) [FAILED] (var test_name) equality 2.)
+
+[COMPLETED] (var test_name)
+
+(end)
diff --git a/data/unit-testing/cast.fate b/data/unit-testing/cast.fate
new file mode 100644
index 0000000..94b8beb
--- /dev/null
+++ b/data/unit-testing/cast.fate
@@ -0,0 +1,103 @@
+(fate_version 1)
+
+(global string test_name)
+
+(set test_name ( CAST ))
+
+(global int i)
+(global float f)
+(global string s)
+
+(set i (cast int ( 42 )))
+
+(assert (= (var i) 42) [FAILED] (var test_name) equality 1: (var i).)
+
+(set f (cast float ( 42.57 )))
+
+(assert (= (var f) 42.57) [FAILED] (var test_name) equality 2: (var f).)
+
+(assert (= (var i) 42 (cast int (var f))) [FAILED] (var test_name) equality 3: (cast int (var f)).)
+
+
+;; TO INT
+(assert (= 42 (cast int 42.72)) [FAILED] (var test_name) float->int: (cast int 42.72).)
+(assert (= 42 (cast int (+ 40.70 2.02))) [FAILED] (var test_name) extra float->int: (cast int (+ 40.70 2.02)).)
+(assert (= 42 (cast int 42)) [FAILED] (var test_name) int->int: (cast int 42).)
+(assert (= 42 (cast int (+ 40 2))) [FAILED] (var test_name) extra int->int: (cast int (+ 40 2)).)
+(assert (= 42 (cast int ( 42 ))) [FAILED] (var test_name) string->int: (cast int ( 42 )).)
+
+;; TO FLOAT
+(assert
+ (>
+ 0.05
+ (abs
+ (-
+ (cast float 42.72)
+ 42.72
+ )
+ )
+ )
+ [FAILED] (var test_name) float->float: (cast float 42.72).
+)
+(assert
+ (> 0.05
+ (abs
+ (-
+ (cast float (+ 40.70 2.02))
+ 42.72
+ )
+ )
+ )
+ [FAILED] (var test_name) extra float->float: (cast float (+ 40.70 2.02)).
+)
+(assert (= 42.0 (cast float 42)) [FAILED] (var test_name) int->float: (cast float 42).)
+(assert (= 42.0 (cast float (+ 40 2))) [FAILED] (var test_name) extra float->float: (cast float (+ 40 2)).)
+(assert
+ (> 0.05
+ (abs
+ (-
+ (cast float ( 42.72 ))
+ 42.72
+ )
+ )
+ )
+ [FAILED] (var test_name) string->float: (cast float ( 42.72 )).
+)
+
+;; TO BOOL
+(assert (= (true) (cast bool (true))) [FAILED] (var test_name) bool->bool: (cast bool (true)).)
+(assert (= (true) (cast bool (or (true) (false)))) [FAILED] (var test_name) extra bool->bool: (cast bool (or (true) (false))).)
+(assert (= (true) (cast bool ( true ))) [FAILED] (var test_name) string->bool: (cast bool ( true )).)
+
+;; TO STRING
+(assert (= ( 42 ) (cast string 42)) [FAILED] (var test_name) int->string: (cast string 42).)
+(assert (= ( 42 ) (cast string (+ 40 2))) [FAILED] (var test_name) extra int->string: (cast string (+ 40 2)).)
+(assert
+ (> 0.05
+ (abs
+ (-
+ (cast float (cast string 42.72))
+ 42.72
+ )
+ )
+ )
+ [FAILED] (var test_name) float->string: (cast string 42.72).
+)
+(assert
+ (> 0.05
+ (abs
+ (-
+ (cast float (cast string (+ 40.7 2.02)))
+ 42.72
+ )
+ )
+ )
+ [FAILED] (var test_name) extra float->string: (cast string (+ 40.7 2.02)).
+)
+(assert (= ( true ) (cast string (true))) [FAILED] (var test_name) bool->string: (cast string (true)).)
+(assert (= ( true ) (cast string (or (true) (false)))) [FAILED] (var test_name) extra bool->string: (cast string (true)).)
+(assert (= ( something ) (cast string ( something ))) [FAILED] (var test_name) string->string: (cast string ( something )).)
+
+[COMPLETED] (var test_name)
+
+(end)
diff --git a/data/unit-testing/cond.fate b/data/unit-testing/cond.fate
new file mode 100644
index 0000000..0eae815
--- /dev/null
+++ b/data/unit-testing/cond.fate
@@ -0,0 +1,179 @@
+(fate_version 1)
+
+(global string test_name)
+
+(set test_name ( COND ))
+
+(global bool test)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; INSTRUCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(cond
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 0.)
+ )
+)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(set test (false))
+
+(cond
+ ((true)
+ (set test (true))
+ )
+)
+
+(assert test [FAILED] (var test_name) Ignored correct branch 0.)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(set test (false))
+
+(cond
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 1.)
+ )
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 2.)
+ )
+ ((true)
+ (set test (true))
+ )
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 3.)
+ )
+)
+
+(assert test [FAILED] (var test_name) Ignored correct branch 1.)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(set test (false))
+
+(cond
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 4.)
+ )
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 5.)
+ )
+ ((true)
+ (set test (true))
+ )
+ ((true)
+ (assert (false) [FAILED] (var test_name) Reached dead code 6.)
+ )
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 7.)
+ )
+)
+
+(assert test [FAILED] (var test_name) Ignored correct branch 2.)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(set test (false))
+
+(cond
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 8.)
+ )
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 9.)
+ )
+ ((true)
+ (set test (true))
+ )
+ ((true)
+ (assert (false) [FAILED] (var test_name) Reached dead code 10.)
+ )
+)
+
+(assert test [FAILED] (var test_name) Ignored correct branch 3.)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(set test (false))
+
+(cond
+ ((false)
+ (cond
+ ((true)
+ (assert (false) [FAILED] (var test_name) Reached dead code 11.)
+ )
+ )
+ )
+ ((false)
+ (cond
+ ((true)
+ (assert (false) [FAILED] (var test_name) Reached dead code 12.)
+ )
+ )
+ )
+ ((true)
+ (cond
+ ((true)
+ (set test (true))
+ )
+ ((false)
+ (assert (false) [FAILED] (var test_name) Reached dead code 13.)
+ )
+ )
+ )
+ ((true)
+ (cond
+ ((true)
+ (assert (false) [FAILED] (var test_name) Reached dead code 14.)
+ )
+ )
+ )
+)
+
+(assert test [FAILED] (var test_name) Ignored correct branch 4.)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; COMPUTATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(assert
+ (cond ((false) (true)))
+ [FAILED] (var test_name) Questionable default value.
+)
+
+(assert
+ (cond ((true) (true)))
+ [FAILED] (var test_name) Simple computation test 0.
+)
+
+(assert
+ (cond
+ ((false) (true))
+ ((true) (true))
+ )
+ [FAILED] (var test_name) Simple computation test 1.
+)
+
+(assert
+ (cond
+ ((true) (true))
+ ((false) (true))
+ )
+ [FAILED] (var test_name) Simple computation test 2.
+)
+
+(assert
+ (cond
+ (
+ (cond
+ ((false) (false))
+ ((false) (false))
+ ((true) (true))
+ ((true) (false))
+ )
+ (true)
+ )
+ ((false) (true))
+ )
+ [FAILED] (var test_name) Obtuse computation test.
+)
+
+[COMPLETED] (var test_name)
+
+(end)
diff --git a/data/unit-testing/cons_car_cdr.fate b/data/unit-testing/cons_car_cdr.fate
new file mode 100644
index 0000000..7187f6a
--- /dev/null
+++ b/data/unit-testing/cons_car_cdr.fate
@@ -0,0 +1,51 @@
+(fate_version 1)
+
+(global string test_name)
+
+(set test_name ( CONS CAR CDR ))
+
+(assert (= (car (cons 1 (cons 2 (cons 3 (cons 4 5))))) 1)
+ [FAILED] (var test_name) test 1: (car (cons 1 (cons 2 (cons 3 (cons 4 5))))).
+)
+
+(assert (= (car (cdr (cons 1 (cons 2 (cons 3 (cons 4 5)))))) 2)
+ [FAILED] (var test_name) test 2:
+ (car (cdr (cons 1 (cons 2 (cons 3 (cons 4 5)))))).
+)
+
+(assert (= (car (cdr (cdr (cons 1 (cons 2 (cons 3 (cons 4 5))))))) 3)
+ [FAILED] (var test_name) test 3:
+ (car (cdr (cdr (cons 1 (cons 2 (cons 3 (cons 4 5))))))).
+)
+
+(assert (= (car (cdr (cdr (cdr (cons 1 (cons 2 (cons 3 (cons 4 5)))))))) 4)
+ [FAILED] (var test_name) test 4:
+ (car (cdr (cdr (cdr (cons 1 (cons 2 (cons 3 (cons 4 5)))))))).
+)
+
+(assert (= (cdr (cdr (cdr (cdr (cons 1 (cons 2 (cons 3 (cons 4 5)))))))) 5)
+ [FAILED] (var test_name) test 5:
+ (cdr (cdr (cdr (cdr (cons 1 (cons 2 (cons 3 (cons 4 5)))))))).
+)
+
+(assert (= (car (cons test 0)) test)
+ [FAILED] (var test_name) test string:
+ (car (cons test 0))
+)
+
+(global (cons float string) cfs)
+(global (cons float string) cfs2)
+
+(set cfs (cons 3.14 pi))
+
+(assert (= (car cfs) 3.14) [FAILED] (var test_name) test 3.14: (car cfs).)
+(assert (= (cdr cfs) pi) [FAILED] (var test_name) test pi: (cdr cfs).)
+
+
+(set cfs2 (cons (car cfs) (cdr cfs)))
+
+(assert (= (var cfs2) (var cfs)) [FAILED] (var test_name) equality.)
+
+[COMPLETED] (var test_name)
+
+(end)
diff --git a/data/unit-testing/ptr_and_at.fate b/data/unit-testing/ptr_and_at.fate
new file mode 100644
index 0000000..2baf6ce
--- /dev/null
+++ b/data/unit-testing/ptr_and_at.fate
@@ -0,0 +1,97 @@
+(fate_version 1)
+
+(global string test_name)
+
+(set test_name ( PTR AND AT ))
+
+(global int i)
+(global int j)
+(global (ptr int) i_ptr)
+(global (ptr int) j_ptr)
+(global (ptr (ptr int)) int_ptr_ptr)
+
+(global (list int) li0)
+(global (list int) li1)
+
+(global (ptr (list int)) li0_ptr)
+(global (ptr (list int)) li1_ptr)
+(global (ptr (ptr (list int))) int_list_ptr_ptr)
+
+(declare_structure test_struct0
+ (int int0)
+ (int int1)
+ ((ptr int) int_ptr0)
+ ((ptr int) int_ptr1)
+ ((list int) int_list)
+ ((list (ptr int)) int_ptr_list)
+ ((ptr (list (ptr int))) int_ptr_list_ptr)
+)
+
+(global (list test_struct0) test_struct0_list)
+
+(declare_structure test_struct1
+ (test_struct0 ts0)
+ ((ptr test_struct0) ts0_ptr)
+ ((list test_struct0) ts0_list)
+ ((list (ptr test_struct0)) ts0_ptr_list)
+ ((ptr (list (ptr test_struct0))) ts0_ptr_list_ptr)
+)
+
+(global (list test_struct1) test_struct1_list)
+
+(set i 100)
+(set j 2000)
+
+(set i_ptr (ptr i))
+(set j_ptr (ptr j))
+
+(set int_ptr_ptr (ptr i_ptr))
+
+(assert (= (var i) (at i_ptr) (at (at int_ptr_ptr))) [FAILED] (var test_name) equality 0.)
+
+(set i_ptr (ptr j))
+
+(assert (= (var j) (at i_ptr) (at (at int_ptr_ptr))) [FAILED] (var test_name) equality 1.)
+
+(global int b)
+
+(set j_ptr (ptr b))
+
+(set (at j_ptr) (at (at int_ptr_ptr)))
+
+(assert (= (var b) (var j) (at i_ptr) (at (at int_ptr_ptr))) [FAILED] (var test_name) equality 2.)
+
+(global (ptr int) b_ptr)
+(set i 100)
+(set j 2000)
+(set i_ptr (ptr i))
+(set j_ptr (ptr j))
+(set b_ptr (ptr b))
+(set int_ptr_ptr (ptr b_ptr))
+
+(global test_struct0 ts0)
+
+(set_fields! ts0
+ (int0 3)
+ (int1 40)
+ (int_ptr0 (ptr ts0.int0))
+ (int_ptr1 (ptr ts0.int1))
+ (int_list (range 0 10 1))
+ (int_ptr_list_ptr (ptr ts0.int_ptr_list))
+)
+
+(add! (ptr i) ts0.int_ptr_list)
+(add! (ptr j) ts0.int_ptr_list)
+(add! (at int_ptr_ptr) ts0.int_ptr_list)
+(add! (var ts0.int_ptr0) ts0.int_ptr_list)
+(add! (var ts0.int_ptr1) ts0.int_ptr_list)
+
+(assert (= (var ts0.int_ptr_list.0) (var i_ptr) (ptr i)) [FAILED] (var test_name) equality 3.)
+(assert (= (var ts0.int_ptr_list.1) (var j_ptr) (ptr j)) [FAILED] (var test_name) equality 4.)
+(assert (= (var ts0.int_ptr_list.2) (var b_ptr) (ptr b)) [FAILED] (var test_name) equality 5.)
+(assert (= (at ts0.int_ptr_list.3) (at ts0.int_ptr0) (at (ptr ts0.int0)) (var ts0.int0)) [FAILED] (var test_name) equality 6.)
+(assert (= (at ts0.int_ptr_list.4) (at ts0.int_ptr1) (at (ptr ts0.int1)) (var ts0.int1)) [FAILED] (var test_name) equality 7.)
+
+[COMPLETED] (var test_name)
+
+(end)
diff --git a/src/core/src/tonkadur/fate/v1/lang/computation/Cast.java b/src/core/src/tonkadur/fate/v1/lang/computation/Cast.java
index 3906499..8e283c9 100644
--- a/src/core/src/tonkadur/fate/v1/lang/computation/Cast.java
+++ b/src/core/src/tonkadur/fate/v1/lang/computation/Cast.java
@@ -3,6 +3,7 @@ package tonkadur.fate.v1.lang.computation;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Map;
import java.util.Set;
@@ -24,55 +25,41 @@ public class Cast extends Computation
static
{
+ Set allowed_targets;
+
allowed_type_changes = new HashMap<Type,Set<Type>>();
- allowed_type_changes.put
- (
- Type.INT,
- Type.NUMBER_TYPES
- );
+ /** INT to ... **********************************************************/
+ allowed_targets = new HashSet<Type>();
+ allowed_targets.add(Type.FLOAT);
+ allowed_targets.add(Type.INT);
+ allowed_targets.add(Type.STRING);
- allowed_type_changes.put
- (
- Type.FLOAT,
- Type.NUMBER_TYPES
- );
+ allowed_type_changes.put(Type.INT, allowed_targets);
- allowed_type_changes.put
- (
- Type.DICT,
- Collections.emptySet()
- );
+ /** FLOAT to ... ********************************************************/
+ allowed_targets = new HashSet<Type>();
+ allowed_targets.add(Type.FLOAT);
+ allowed_targets.add(Type.INT);
+ allowed_targets.add(Type.STRING);
- allowed_type_changes.put
- (
- Type.SET,
- Collections.emptySet()
- );
+ allowed_type_changes.put(Type.FLOAT, allowed_targets);
- allowed_type_changes.put
- (
- Type.LIST,
- Collections.emptySet()
- );
+ /** BOOL to ... *********************************************************/
+ allowed_targets = new HashSet<Type>();
+ allowed_targets.add(Type.BOOL);
+ allowed_targets.add(Type.STRING);
- allowed_type_changes.put
- (
- Type.BOOL,
- Collections.emptySet()
- );
+ allowed_type_changes.put(Type.BOOL, allowed_targets);
- allowed_type_changes.put
- (
- Type.ANY,
- Collections.singleton(Type.ANY)
- );
+ /** BOOL to ... *********************************************************/
+ allowed_targets = new HashSet<Type>();
+ allowed_targets.add(Type.BOOL);
+ allowed_targets.add(Type.INT);
+ allowed_targets.add(Type.FLOAT);
+ allowed_targets.add(Type.STRING);
- allowed_type_changes.put
- (
- Type.STRING,
- Type.COMPARABLE_TYPES
- );
+ allowed_type_changes.put(Type.STRING, allowed_targets);
}
public static Collection<Type> get_allowed_casts_to (final Type t)
@@ -125,14 +112,15 @@ public class Cast extends Computation
(value.get_type().can_be_used_as(to))
||
(
- (to.is_base_type())
- &&
+ allowed_type_changes.containsKey
(
- allowed_type_changes.get(to).contains
- (
- value.get_type().get_act_as_type()
- )
+ value.get_type().get_act_as_type().get_base_type()
)
+ &&
+ allowed_type_changes.get
+ (
+ value.get_type().get_act_as_type().get_base_type()
+ ).contains(to.get_act_as_type())
)
)
{