(fate_version 1)

(global string test_name)

(set! test_name ( MERGE ))

(local int i)
(local int j)

(local (set int) oracle_set)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (list int) li0)
(global (list int) li0oa)
(global (list int) li0ob)
(global (list int) li1)
(global (list int) li1oa)
(global (list int) li1ob)

(set! li0
   (list:merge
      (lambda
         (
            (int a)
            (int b)
         )
         (- b a)
      )
      (list:range 0 60 2)
      (list:range 10 40 1)
   )
)

(set! li0oa
   (list:merge
      (lambda
         (
            (int a)
            (int b)
         )
         (- b a)
      )
      (list:range 0 60 2)
      (list:range 10 70 1)
   )
)

(set! li0ob
   (list:merge
      (lambda
         (
            (int a)
            (int b)
         )
         (- b a)
      )
      (list:range 0 80 2)
      (list:range 10 40 1)
   )
)

(assert!
   (= (var li0) (var li0oa) (var li0ob))
   [FAILED] (var test_name) Equality test 0.
)

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) si0)
(global (set int) si0oa)
(global (set int) si0ob)

(set! si0
   (set:merge
      (lambda
         (
            (int a)
            (int b)
         )
         (- b a)
      )
      (list:range 0 60 2)
      (list:range 10 40 1)
   )
)

(set! si0oa
   (set:merge
      (lambda
         (
            (int a)
            (int b)
         )
         (- b a)
      )
      (list:range 0 60 2)
      (list:range 10 70 1)
   )
)

(set! si0ob
   (set:merge
      (lambda
         (
            (int a)
            (int b)
         )
         (- b a)
      )
      (list:range 0 80 2)
      (list:range 10 40 1)
   )
)

(assert!
   (= (var si0) (var si0oa) (var si0ob))
   [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!
      (=
         (- (+ 10 j) (* 2 j))
         (set:access i si0)
         (set:access i si0oa)
         (set:access i si0ob)
      )
      [FAILED] (var test_name) Basic test 1, index (var i), values:
      Expected: (- (+ 10 j) (* 2 j));
      si0: (set:access i si0);
      si0oa: (set:access i si0oa);
      si0ob: (set:access i si0ob);
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) si2)
(global (set int) si2oa)
(global (set int) si2ob)

(set! si2
   (set:merge
      (lambda
         (
            (int a)
            (int b)
            (int mod)
         )
         (* (- b a) mod)
      )
      (list:range 0 60 2)
      (list:range 10 40 1)
      -1
   )
)

(set! si2oa
   (set:merge
      (lambda
         (
            (int a)
            (int b)
            (int mod)
         )
         (* (- b a) mod)
      )
      (list:range 0 60 2)
      (list:range 10 80 1)
      -1
   )
)

(set! si2ob
   (set:merge
      (lambda
         (
            (int a)
            (int b)
            (int mod)
         )
         (* (- b a) mod)
      )
      (list:range 0 80 2)
      (list:range 10 40 1)
      -1
   )
)

(assert!
   (= (var si2) (var si2oa) (var si2ob))
   [FAILED] (var test_name) Equality test 2.
)

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; INDEXED TEST 0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (list int) ili0)
(global (list int) ili0oa)
(global (list int) ili0ob)

(set! ili0
   (list:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- b a) i)
      )
      (list:range 0 60 2)
      (list:range 10 40 1)
   )
)

(set! ili0oa
   (list:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- b a) i)
      )
      (list:range 0 60 2)
      (list:range 10 70 1)
   )
)

(set! ili0ob
   (list:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- b a) i)
      )
      (list:range 0 80 2)
      (list:range 10 40 1)
   )
)

(assert!
   (= (var ili0) (var ili0oa) (var ili0ob))
   [FAILED] (var test_name) Equality test indexed 0.
)

(for (set! i 0) (=< i 30) (set! i (+ i 1))
   (assert!
      (=
         (* (- (+ 10 i) (* 2 i)) i)
         (list:access i ili0)
         (list:access i ili0oa)
         (list:access i ili0ob)
      )
      [FAILED] (var test_name) Indexed test 0, index (var i), values:
      Expected: (* (- (+ 10 i) (* 2 i)) i);
      ili0: (list:access i ili0);
      ili0oa: (list:access i ili0oa);
      ili0ob: (list:access i ili0ob);
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; INDEXED TEST 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
For reference, the values found in the sets are:
(for (set! i 0) (=< i 30) (set! i (+ i 1))
   (local int o)
   (set! o (* (- (+ 10 i) (* 2 i)) (+ i 1)))
   (var o) (newline)
   (set:add! (var o) oracle_set)
)

(global (set int) isi0)
(global (set int) isi0oa)
(global (set int) isi0ob)

(set! isi0
   (set:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- b a) (+ i 1))
      )
      (list:range 0 60 2)
      (list:range 10 40 1)
   )
)

(set! isi0oa
   (set:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- b a) (+ i 1))
      )
      (list:range 0 60 2)
      (list:range 10 70 1)
   )
)

(set! isi0ob
   (set:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- b a) (+ i 1))
      )
      (list:range 0 80 2)
      (list:range 10 40 1)
   )
)

(assert!
   (= (var isi0) (var isi0oa) (var isi0ob))
   [FAILED] (var test_name) Equality test indexed 1.
)

(for (set! i (- (set:size oracle_set) 1)) (>= i 0) (set! i (- i 1))
   (assert!
      (=
         (set:access i oracle_set)
         (set:access i isi0)
         (set:access i isi0oa)
         (set:access i isi0ob)
      )
      [FAILED] (var test_name) Indexed test 1, index (var i), values:
      Expected: (set:access i oracle_set);
      isi0: (set:access i isi0);
      isi0oa: (set:access i isi0oa);
      isi0ob: (set:access i isi0ob);
   )
)

(set:clear! oracle_set)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; INDEXED TEST 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

For reference, the values found in the sets are:
(for (set! i 0) (=< i 30) (set! i (+ i 1))
   (local int o)
   (set! o (* (- (+ 10 i) (* 2 i)) -1 (+ i 1)))
   (var o) (newline)
   (set:add! (var o) oracle_set)
)

(global (set int) isi2)
(global (set int) isi2oa)
(global (set int) isi2ob)
(global (set int) isi3)
(global (set int) isi3oa)
(global (set int) isi3ob)

(set! isi2
   (set:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
            (int mod)
         )
         (* (* (- b a) mod) (+ i 1))
      )
      (list:range 0 60 2)
      (list:range 10 40 1)
      -1
   )
)

(set! isi2oa
   (set:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
            (int mod)
         )
         (* (* (- b a) mod) (+ i 1))
      )
      (list:range 0 60 2)
      (list:range 10 80 1)
      -1
   )
)

(set! isi2ob
   (set:indexed_merge
      (lambda
         (
            (int i)
            (int a)
            (int b)
            (int mod)
         )
         (* (- b a) mod (+ i 1))
      )
      (list:range 0 80 2)
      (list:range 10 40 1)
      -1
   )
)

(assert!
   (= (var isi2) (var isi2oa) (var isi2ob))
   [FAILED] (var test_name) Equality test indexed 2.
)

(for (set! i (- (set:size oracle_set) 1)) (>= i 0) (set! i (- i 1))
   (assert!
      (=
         (set:access i oracle_set)
         (set:access i isi2)
         (set:access i isi2oa)
         (set:access i isi2ob)
      )
      [FAILED] (var test_name) Indexed test 2, index (var i), values:
      Expected: (set:access i oracle_set);
      isi2: (set:access i isi2);
      isi2oa: (set:access i isi2oa);
      isi2ob: (set:access i isi2ob);
   )
)

[COMPLETED] (var test_name)

(end!)