#lang racket

(require "test-util.rkt")
(require "remove-complex-oper.rkt")
(require "explicate-control.rkt")
(require "c2.rkt")

(define programs
  (list
   `(program () (+ 2 3))
   `(program () (+ (- 2) 3))
   `(program ()
             (let ([y (let ([x 20])
                        (+ x (let ([x 22]) x)))]) y))
   `(program ()
      (let ([a 42])
        (let ([b a])
          b)))

   `(program () (+ (let ([x (+ (- 1) 2)]) (+ x 2)) (+ 4 5)))))

(define (pass program) (explicate-control (remove-complex-opera* program)))

(test-eq
 (pass (list-ref programs 0))
 `(program ()
           ((start .
             (return (+ 2 3))))))

(test-eq
 (pass (list-ref programs 1))
 `(program ()
           ((start .
             (seq (assign tmp.1 (- 2))
              (return (+ tmp.1 3)))))))

(test-eq
  (pass (list-ref programs 2))
  `(program ()
            ((start .
              (seq (assign x.1 20)
               (seq (assign x.2 22)
                (seq (assign y.1 (+ x.1 x.2))
                 (return y.1))))))))

(test-eq
 (pass (list-ref programs 3))
 `(program ()
           ((start .
             (seq (assign a.1 42)
                  (seq (assign b.1 a.1)
                       (return b.1)))))))

(test-eq
 (pass (list-ref programs 4))
 `(program ()
           ((start .
             (seq (assign tmp.1 (- 1))
                  (seq (assign x.1 (+ tmp.1 2))
                       (seq (assign tmp.2 (+ x.1 2))
                            (seq (assign tmp.3 (+ 4 5))
                                 (return (+ tmp.2 tmp.3))))))))))