(fate_version 1)

(global string test_name)

(set test_name ( MERGE ))

(local int i)
(local int j)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (list int) li0)
(global (list int) li1)

(set li0
   (merge_to_list
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 40 1)
      (range 0 60 2)
   )
)

(set li1 (range 10 40 1))

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   li1
   (range 0 60 2)
)

(assert
   (= (var li1) (var li0))
   [FAILED] (var test_name) Equality test 0.
)

(for (set i 0) (=< i 30) (set i (+ i 1))
   (assert
      (= (access li1 i) (access li0 i) (- (+ 10 i) (* 2 i)))
      [FAILED] (var test_name) Basic test 0, index (var i), values:
      li0: (access li0 i);
      li1: (access li1 i);
      Expected: (- (+ 10 i) (* 2 i))
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) si0)
(global (set int) si1)

(set si0
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 40 1)
      (range 0 60 2)
   )
)

(add_all! (range 10 40 1) si1)

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   si1
   (range 0 60 2)
)

(assert
   (= (var si1) (var si0))
   [FAILED] (var test_name) Equality test 1.
)

(for
   (
      (set i 0)
      (set j 30)
   )
   (=< i 30)
   (
      (set i (+ i 1))
      (set j (- j 1))
   )
   (assert
      (= (access si1 i) (access si0 i) (- (+ 10 j) (* 2 j)))
      [FAILED] (var test_name) Basic test 1, index (var i), values:
      si0: (access si0 i);
      si1: (access si1 i);
      Expected: (- (+ 10 j) (* 2 j))
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) si2)
(global (set int) si3)

(set si2
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
            (int mod)
         )
         (* (- a b) mod)
      )
      (range 10 40 1)
      (range 0 60 2)
      -1
   )
)

(add_all! (range 10 40 1) si3)

(merge!
   (lambda
      (
         (int a)
         (int b)
         (int mod)
      )
      (* (- a b) mod)
   )
   si3
   (range 0 60 2)
   -1
)

(assert
   (= (var si3) (var si2))
   [FAILED] (var test_name) Equality test 0.
)

(for
   (
      (set i 0)
      (set j 30)
   )
   (=< i 30)
   (
      (set i (+ i 1))
      (set j (- j 1))
   )
   (assert
      (= (access si3 i) (access si2 i) (* (- (+ 10 i) (* 2 i)) -1))
      [FAILED] (var test_name) Basic test 2, index (var i), values:
      si2: (access si2 i);
      si3: (access si3 i);
      Expected: (* (- (+ 10 i) (* 2 i)) -1)
   )
)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 3 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;(clear li0)
;;(clear li1)
;;
;;(set li0
;;   (indexed_map
;;      (lambda ((int ix) (int i)) (+ (* i ix) 1000))
;;      (range 10 20 1)
;;   )
;;)
;;
;;(set li1 (range 10 20 1))
;;
;;(indexed_map!
;;   (lambda ((int ix) (int i)) (+ (* i ix) 1000))
;;   li1
;;)
;;
;;(for (set i 0) (=< i 10) (set i (+ i 1))
;;   (assert
;;      (=
;;         (access li1 i) (access li0 i) (access li2 i) (access li3 i)
;;         (+ (* i (+ 10 i)) 1000)
;;      )
;;      [FAILED] (var test_name) Indexed map at (var i):
;;      (access li1 i), (access li0 i), (access li2 i), (access li3 i)
;;   )
;;)

[COMPLETED] (var test_name)

(end)