;;; Commentary
;; Test implementation details of C parser
;; TODO Should be ran before (test cpp)
;;; Code

(define-module (test cpp)
  :use-module (srfi srfi-64)
  :use-module (srfi srfi-88)
  :use-module ((c old lex) :select (lex))
  :use-module (c old parse))

(define flatten-infix (@@ (c old parse) flatten-infix))
(define resolve-order-of-operations (@@ (c old parse) resolve-order-of-operations))

(test-group "Flatten infix"
 (test-equal "Simple binary operator"
   '(fixed-infix (integer (base-10 "1"))
                 +
                 (integer (base-10 "2")))
   (flatten-infix (lex "1 + 2")))

 (test-equal "Simple binary operator, with compound structure in on branch"
   '(fixed-infix (integer (base-10 "1"))
                 +
                 (funcall (variable "f")
                          (group (integer (base-10 "2")))))
   (flatten-infix (lex "1 + f(2)"))))

(test-group "Order of operations"
  (test-equal "Basic binary operator"
    '((resolved-operator +)
      (integer (base-10 "1"))
      (integer (base-10 "2")))
    (resolve-order-of-operations (flatten-infix (lex "1 + 2"))))

  (test-equal "Multiple operators, with non-left-associative application"
    '((resolved-operator +)
      (integer (base-10 "1"))
      ((resolved-operator *)
       (integer (base-10 "2"))
       (integer (base-10 "3"))))
    (resolve-order-of-operations (flatten-infix (lex "1 + 2 * 3"))))

  (test-equal "Multiple of the same operation gets clumed together"
    '((resolved-operator +)
      (integer (base-10 "1"))
      (integer (base-10 "2"))
      (integer (base-10 "3")))
    (resolve-order-of-operations (flatten-infix (lex "1 + 2 + 3"))))

  (test-equal "Simple Ternary"
    '(ternary
      (integer (base-10 "1"))
      (integer (base-10 "2"))
      (integer (base-10 "3")))
    (resolve-order-of-operations (flatten-infix (lex "1 ? 2 : 3"))))

  (test-equal "ternary with further infix operators"
    '(ternary ((resolved-operator +)
               (integer (base-10 "1"))
               (integer (base-10 "2")))
              ((resolved-operator %)
               (integer (base-10 "3"))
               (integer (base-10 "4")))
              ((resolved-operator *)
               (integer (base-10 "5"))
               (integer (base-10 "6"))))
    (resolve-order-of-operations (flatten-infix (lex "1 + 2? 3 % 4 : 5 * 6")))))