parse-tests.rkt

#lang rosette

(require "parse.rkt")
(require "expression-writer.rkt")

(define (test1)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("if" "A" "==" "B" "then" "C"))))
    (println result)))

(define (test2)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("if" "A" "=" "B" "then" "C"))))
    (println result)))

(define (test3)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("if" "A" "is" "equal" "to" "B" "then" "C"))))
    (println result)))

(define (test4)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("if" "A" "is" "equal" "to" "B" "then" "C"))))
    (println result)))

(define (test5)
  (letrec ((p (apply make-parser '("A" "B" "C" "D")))
           (result (p '("if" "A" "is" "equal" "to" "B" "then" "C" "or" "else" "D"))))
    (println result)))

(define (test6)
  (letrec ((p (apply make-parser '("A" "B" "C" "D")))
           (result (p '("if" "A" "is" "equal" "to" "B" "then" "C" "else" "D"))))
    (println result)))

(define (test7)
  (letrec ((p (apply make-parser '("A" "B" "C" "D")))
           (result (p '("if" "A" "is" "equal" "to" "B" "then" "C" "otherwise" "D"))))
    (println result)))

(define (test8)
   (letrec ((p (apply make-parser '("A" "B" "C" "D" "E" "F" "G" "H")))
           (result (p '("if" "A" "is" "foo" "then" "B" "otherwise" "0"
                             "+" "if" "A" "is" "bar" "then" "(" "B" "*" "C" ")" "+" "D" "else" "0"
                             "+" "if" "A" "is" "baz" "then" "E" "*" "F" "*" "G" "*" "H"))))
    (println result)))

(define (test9)
   (letrec ((p (apply make-parser '("A" "B" "C" "D" "E" "F" "G" "H")))
           (result (p '("(" "if" "A" "is" "foo" "then" "B" "otherwise" "0" ")"
                             "+" "(" "if" "A" "is" "bar" "then" "(" "B" "*" "C" ")" "+" "D" "else" "0" ")"
                             "+" "(" "if" "A" "is" "baz" "then" "E" "*" "F" "*" "G" "*" "H" ")"))))
    (println result)))

(define (test10)
    (letrec ((p (apply make-parser '("A" "B" "C" "D" "E" "F")))
           (result (p '("if" "A" "is" "greater" "than" "B" "and" "C" "is" "greater" "than" "D" 
                             "and" "E" "is" "not" "null" "then" "F" "=" "coo" "or" "F" "=" "roo"))))
    (println result)))

(define (test11)
    (letrec ((p (apply make-parser '("A" "B" "C" "D" "E" "F")))
           (result (p '("if" "(" "(" "A" "is" "greater" "than" "B" ")" "and" "(" "C" "is" "greater" "than" "D" ")" 
                             "and" "(" "E" "is" "not" "null" ")" ")" "then" "(" "F" "=" "coo" "or" "F" "=" "roo" ")"))))
    (println result)))

(define (test11a)
    (letrec ((p (apply make-parser '("A" "B" "C" "D" "E" "F")))
           (result (p '("if" "(" "(" "A" ">" "B" ")" "and" "(" "C" ">" "D" ")" 
                             "and" "(" "E" "=" "25" ")" ")" "then" "(" "F" "=" "coo" "or" "F" "=" "roo" ")"))))
    (println result)))

(define (test11b)
    (letrec ((p (apply make-parser '("A" "B" "C" "D" "E" "F")))
           (result (p '("if" "(" "A" ">" "B" ")" "and" "(" "C" ">" "D" ")" 
                             "and" "(" "E" "not" "25" ")" "then" "(" "F" "=" "coo" "or" "F" "=" "roo" ")"))))
    (println result)))

(define (test12)
      (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("A" "is" "greater" "than" "B"))))
    (println result)))

(define (test13)
      (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("A" "is" "equal" "to" "B"))))
    (println result)))

(define (test14)
       (letrec ((p (apply make-parser '("A")))
           (result (p '("if" "A" "<" "500" "then" "t3" "else" "if" "A" "<" "1000" "then" "t4" "else" "if" "A" "<" "1500" "then" "t5" "else" "t6"))))
    (println result)))

(define (test15)
       (letrec ((p (apply make-parser '("terms" "min_servers" "price_per_server")))
           (result (p '("if" "terms" "==" "Committed" "then" "min_servers" "*" "price_per_server" "or" "else" "0"))))
    (println result)))

(define (test16)
       (letrec ((p (apply make-parser '("price_per_server" "server")))
           (result (p '("price_per_server" "grouped" "by" "server"))))
    (println result)))

(define (test17)
  (letrec ((p (apply make-parser '("price_per_server" "min_servers" "terms" "top99" "container_overage")))
           (result (p '("if" "terms" "is" "Committed" "then" "price_per_server" "*" "min_servers"
                          "otherwise" "if" "terms" "is" "Standard" "then" "top99" "*" "min_servers" "plus" "container_overage" "otherwise" "0"))))
          (println result)))

(define (test18)
  (letrec ((p (apply make-parser '("price_per_server" "min_servers" "terms" "top99" "container_overage")))
           (result (p  '("if" "terms" "is" "Committed" "then" "price_per_server" "times" "min_servers" "else" "0" "plus"
                          "if" "terms" "is" "Standard" "then" "top99" "times" "price_per_server" "plus" "container_overage" "else" "0"))))
     (println result)))

(define (test19)
  (letrec ((p (apply make-parser '("price_per_server" "min_servers" "terms" "top99" "container_overage")))
           (result (p '("if" "terms" "is" "Committed" "then" "price_per_server" "times"
                             "min_servers" "otherwise" "0" "otherwise" "if" "terms" "is" "Standard"
                             "then" "top99" "times" "price_per_server" "plus" "container_overage" "otherwise" "0"))))
    (println result)))

(define (test20)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("average" "A" "+" "B"))))
    (println result)))

(define (test21)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("average" "A" "+" "B" "group" "by" "C"))))
    (println result)))

(define (test22)
  (letrec ((p (apply make-parser '("A" "B" "C" "D")))
           (result (p '("average" "of" "A" "+" "B" "group" "by" "C" "+" "D"))))
    (println result)))

(define (test23)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("average" "A" "+" "B" "group" "by" "C" "+" "D"))))
    (println result)))

(define (test23a)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("average" "if" "C" "==" "bad" "then" "A" "+" "B"))))
    (println result)))

(define (test24)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("string" "length" "of" "A"))))
    (println result)))

(define (test25)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("index" "of" "A" "in" "B"))))
    (println result)))

(define (test26)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("extract" "seconds" "from" "A"))))
    (println result)))

(define (test27)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("find" "minutes" "from" "A"))))
    (println result)))

(define (test28)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("retrieve" "days" "from" "A"))))
    (println result)))

(define (test29)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("get" "hours" "from" "A"))))
    (println result)))

(define (test30)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("fetch" "months" "from" "A"))))
    (println result)))

(define (test31)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("grab" "years" "from" "A"))))
    (println result)))

(define (test32)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("grab" "day" "of" "week" "from" "A"))))
    (println result)))

(define (test33)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("fetch" "day" "of" "year" "from" "A"))))
    (println result)))

; substring
(define (test34)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("find" "A" "in" "B"))))
    (println result)))

(define (test35)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("extract" "characters" "from" "A" "starting" "at" "0" "ending" "at" "5"))))
    (println result)))

(define (test36)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("extract" "characters" "from" "A" "starting" "at" "0" "ending" "at" "5"))))
    (println result)))

(define (test37)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("append" "A" "to" "B"))))
    (println result)))

; does not work.  suspect keywords for multiply/divide etc are broken in the parser
(define (test39)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("quotient" "of" "A" "divided" "by" "B"))))
    (println result)))

(define (test40)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("remainder" "of" "A" "/" "B"))))
    (println result)))

(define (test41)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("ceiling" "of" "A" "/" "B"))))
    (println result)))

(define (test42)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("floor" "of" "A" "/" "B"))))
    (println result)))

(define (test43)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("absolute" "value" "of" "A" "/" "B"))))
    (println result)))

(define (test44)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("sign" "of" "A" "/" "B"))))
    (println result)))

(define (test45)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("truncate" "A" "/" "B"))))
    (println result)))

(define (test46)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("logarithm" "of" "A" "/" "B"))))
    (println result)))

(define (test47)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("exponent" "of" "A" "*" "B"))))
    (println result)))

(define (test48)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("square" "root" "of" "A" "*" "B"))))
    (println result)))

(define (test49)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("current" "time"))))
    (println result)))

(define (test50)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("remove" "extra" "white" "spaces" "from" "A"))))
    (println result)))

(define (test51)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("mean" "of" "A"))))
    (println result)))

(define (test52)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("count" "of" "A"))))
    (println result)))

(define (test53)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("sum" "A"))))
    (println result)))

(define (test54)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("maximum" "of" "A"))))
    (println result)))

(define (test55)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("minimum" "of" "A"))))
    (println result)))

(define (test56)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("add" "seconds" "to" "A"))))
    (println result)))

(define (test57)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("add" "minutes" "to" "A"))))
    (println result)))

(define (test58)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("add" "hours" "to" "A"))))
    (println result)))

(define (test59)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("add" "days" "to" "A"))))
    (println result)))

(define (test60)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("add" "months" "to" "A"))))
    (println result)))

(define (test61)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("add" "years" "to" "A"))))
    (println result)))


(define (test62)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("subtract" "seconds" "from" "A"))))
    (println result)))

(define (test63)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("subtract" "minutes" "from" "A"))))
    (println result)))

(define (test64)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("subtract" "hours" "from" "A"))))
    (println result)))

(define (test65)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("subtract" "days" "from" "A"))))
    (println result)))

(define (test66)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("subtract" "months" "from" "A"))))
    (println result)))

(define (test67)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("subtract" "years" "from" "A"))))
    (println result)))


(define (test68)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("A" "divided" "by" "B"))))
    (println result)))

(define (test69)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("average" "A" "group" "by" "B")))
           (columnMetadata '((columnName "A" primitiveTypes (1)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test70)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("to" "upper" "case" "A")))
           (columnMetadata '((columnName "A" primitiveTypes (3)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test71)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("to" "upper" "case" "(" "A" ")")))
           (columnMetadata '((columnName "A" primitiveTypes (3)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test72)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("extract" "seconds" "from" "A")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test73)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("index" "of" "foo" "in" "A")))
           (columnMetadata '((columnName "A" primitiveTypes (3)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test74)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("add" "10" "seconds" "to" "A")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test75)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("like" "(" "A" "," "B" ")")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))
           
(define (test76)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("values" "in" "(" "A" "," "B" ")")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test77)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("member" "of" "A" "in" "B")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test78)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("A" "like" "B")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test79)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("A" "is" "null")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test80)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("A" "is" "not" "blank")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test81)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("concat" "A" "and" "B")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test82)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("not" "(" "A" ")")))
           (columnMetadata '((columnName "A" primitiveTypes (4)) (columnName "B" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test83)
  (letrec ((p (apply make-parser '("A" "B")))
           (result (p '("A" "-" "B")))
           (columnMetadata '((columnName "A" primitiveTypes (2)) (columnName "B" primitiveTypes (2)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test84)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "terms" "is" "Committed" "then"
                             "price_per_unit" "times" "min_units"
                             "otherwise" "0" "otherwise" "if" "terms" "is" "Standard"
                             "then top99p" "times" "price_per_unit" "plus" "monthly_overage" "otherwise" "0")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test85)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "terms" "is" "Committed" "then"
                             "price_per_unit" "times" "min_units"
                             "otherwise" "0" "otherwise" "if" "terms" "is" "Standard"
                             "then top99p" "times" "price_per_unit" "plus" "monthly_overage" "otherwise" "0")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test86)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "terms" "is" "Committed" "then"
                             "price_per_unit" "times" "min_units"
                             "otherwise" "if" "terms" "is" "Standard"
                             "then" "top99p" "times" "price_per_unit" "plus" "monthly_overage" "else" "0")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test87)
  (letrec ((p (apply make-parser '("last_hour")))
           (result (p '("if" "last_hour" "is" "before" "12/21/2015" "then" "False" "otherwise" "True")))
           (columnMetadata '((columnName "last_hour" primitiveTypes (1)))))
    (println result)
    (println (length result))
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test88)
  (letrec ((p (apply make-parser '("std_plan_billable_hours")))
           (result (p '("std_plan_billable_hours" "times" "0.002")))
           (columnMetadata '((columnName "last_hour" primitiveTypes (1)))))
    (println result)
    (println (length result))
    (println (to-html (car result) columnMetadata))
    (println (jsonify (car result) columnMetadata))))

(define (test89)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "terms" "is" "Committed" "then" "if" "monthly_overage"
                             "is" "not" "null" "then" "monthly_overage" "else" "0" "else" "0")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test90)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "monthly_overage"
                             "is" "not" "null" "then" "monthly_overage" "else" "0")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test91)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "monthly_overage"
                             "is" "not" "null" "and" "terms" "is" "A" "then" "monthly_overage" "else" "0")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test92)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "length" "(" "monthly_overage" ")"
                             ">" "0" "and" "terms" "is" "A" "then" "monthly_overage" "else" "0")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test93)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("price_per_unit" "over" "monthly_overage")))
           (columnMetadata '((columnName "terms" primitiveTypes (1)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test94)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("terms" "is" "'battle tested'")))
           (columnMetadata '((columnName "terms" primitiveTypes (3)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test95)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "(" "string" "length" "of" "terms" ">" "5" ")" "then" "5" "else" "4")))
           (columnMetadata '((columnName "terms" primitiveTypes (3)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test95a)
  (letrec ((p (apply make-parser '("terms" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("if" "(" "average" "terms" ">" "5" ")" "then" "5" "else" "4")))
           (columnMetadata '((columnName "terms" primitiveTypes (3)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test96)
  (letrec ((p (apply make-parser '("total time" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("sum" "of" "total time" "by" "min_units" "and" "monthly_overage")))
           (columnMetadata '((columnName "terms" primitiveTypes (3)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test97)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("if" "(" "if" "A" "==" "B" "then" 5 "else" 4 ")" "then" "C"))))
    (println result)))

(define (test98)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("if" "A" "==" "B" "then" "null" "else" 4))))
    (println result)))

(define (test99)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("if" "A" "is" "not" "null" "then" "B" "else" 4))))
    (println result)))


(define (test100)
  (letrec ((p (apply make-parser '("total time" "price_per_unit" "min_units" "top99p" "monthly_overage")))
           (result (p '("sum" "of" "total time" "by" "min_units" "and" "monthly_overage")))
           (columnMetadata '((columnName "terms" primitiveTypes (3)) (columnName "price_per_unit" primitiveTypes (1))
                                                                     (columnName "min_units" primitiveTypes (1))(columnName "top99p" primitiveTypes (1))
                                                                     (columnName "monthly_overage" primitiveTypes (1)))))
    (println result)
    (println (length result))))

(define (test101)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("date" 20 "days" 2 "months" 1969 "years"))))
    (println result)))

(define (test102)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("date" "(" "2" "11" "1969" ")"))))
    (println result)))

(define (test103)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("date" "(" "2" "," "11" "," "1969" ")"))))
    (println result)))

(define (test104)
  (letrec ((p (apply make-parser '("A" "B" "C")))
           (result (p '("time" "(" "2" "," "11" "," "1969" ")"))))
    (println result)))

(define (test105)
  (letrec ((p (apply make-parser '("Start Date")))
           (result (p '("if" "(" "day" "Start Date" ")" ">" "15" "then" "(" "date" "1" "days" "(" "month" "Start Date" ")" "+" "1" "months"
                             "(" "year" "Start Date" ")" "years" ")" "else"
                             "(" "date" "1" "days" "(" "month" "Start Date" ")" "months" "(" "year" "Start Date" ")" "years" ")"))))
    (println result)
    (println (length result))))

(define (test106)
  (letrec ((p (apply make-parser '("Start Date")))
           (result (p '("if" "(" "epoch" "Start Date" ">" "15" ")" "then" "Start Date" "else" "Start Date"))))
    (println result)))

(define (test107)
  (letrec ((p (apply make-parser '("Start Date")))
           (result (p '("if" "(" "index" "of" "Start Date" "foo" ")" ">" "15" "then" "Start Date" "else" "Start Date"))))
    (println result)))

(define (test108)
    (letrec ((p (apply make-parser '("Start Date" "Term Date")))
           (result (p '("date" "1" "days" "(" "month" "Start Date" ")" "+" "(" "round" "Term Date" "-" "Start Date" "/" "30" ")" "+" "1"
                               "months" "(" "year" "Start Date" ")" "years"))))
    (println result)))

(define (test109)
    (letrec ((p (apply make-parser '("Start Date" "Term Date")))
           (result (p '( "date" "1" "days" "(" "month" "Start Date" ")" "+" "1" "months" "(" "year" "Start Date" ")" "years"))))
    (println result)
    (println (length result))))

(define (test110)
    (letrec ((p (apply make-parser '("Start Date" "Term Date")))
           (result (p '( "date" "1" "days" "(" "month" "Start Date" ")" "months" "(" "year" "Start Date" ")" "years"))))
    (println result)))

(define (test111)
    (letrec ((p (apply make-parser '("Start Date" "Term Date")))
           (result (p '( "Start Date" - "Term Date"))))
    (println result)))

(define (test112)
    (letrec ((p (apply make-parser '("Start Date" "Organization")))
           (result (p '( "sum" "(" "if" "Start Date" ">" "12-3-2015" "then" "Start Date" "else" "0" ")" "by" "Organization"))))
    (println result)))

(define (test113)
  (letrec ((p (apply make-parser '("Hourly overage" "Is_Valid" "Min servers" "Notes" "Pay_Cycle" "Pay_Method" "Price_Per_Server" "Terms" "Valid_From" "Valid_To" "agent_first_count" "agent_hwm" "agent_last_count" "agent_lwm" "average" "aws_lwm" "aws_first_count" "aws_hwm" "aws_last_count" "elapsed_hours" "first_count" "first_hour" "hwm" "last_count" "last_hour" "lwm" "server_hours" "std_dev" "top13" "top25" "top95p" "top99p" "std_plan_billable_hours" "MRR")))
           (result (p '("if" "Terms" "is" "Committed" "and" "Hourly overage" "is" "not" "blank" "then" "Hourly overage" "else" "0" "else" "99"))))
    (println result)
    (println (length result))))

(define (test114)
    (letrec ((p (apply make-parser '("col1")))
           (result (p '("set" "date" "to" "next" "month" "(" "col1" ")"))))
    (println result)
    (println (length result))))

(define (test115)
    (letrec ((p (apply make-parser '("Hourly overage" "Monthly overage" "Is_Valid" "Min servers" "Notes" "Pay_Cycle" "Pay_Method" "Price_Per_Server" "Price per server" "Terms" "Valid_From" "Valid_To" "agent_first_count" "agent_hwm" "agent_last_count" "agent_lwm" "average" "aws_lwm" "aws_first_count" "aws_hwm" "aws_last_count" "elapsed_hours" "first_count" "first_hour" "hwm" "last_count" "last_hour" "lwm" "server_hours" "std_dev" "top13" "top25" "top95p" "top99p" "std_plan_billable_hours" "MRR")))
           (result (p '("if" "Terms" "=" "Committed" "then" "Price_Per_Server" "*" "Min servers" "otherwise" "0" "otherwise" "if" "Terms" "=" "Standard" "then" "top99p" "*" "Price_Per_Server" "plus" "Monthly overage" "otherwise" "0"))))
    (println result)
    (println (length result))))

(define (test116)
    (letrec ((p (apply make-parser '("Hourly overage" "Monthly overage" "Is_Valid" "Min servers" "Notes" "Pay_Cycle" "Pay_Method" "Price_Per_Server" "Price per server" "Terms" "Valid_From" "Valid_To" "agent_first_count" "agent_hwm" "agent_last_count" "agent_lwm" "average" "aws_lwm" "aws_first_count" "aws_hwm" "aws_last_count" "elapsed_hours" "first_count" "first_hour" "hwm" "last_count" "last_hour" "lwm" "server_hours" "std_dev" "top13" "top25" "top95p" "top99p" "std_plan_billable_hours" "MRR")))
           (result (p '("(" "if" "(" "Terms" "=" "Committed" ")" "then" "(" "Price_Per_Server" "*" "Min servers" ")" "otherwise" "if" "(" "Terms" "=" "Standard" ")" "then" "(" "(" "top99p" "*" "Price_Per_Server" ")" "plus" "Monthly overage" ")" "otherwise" "0" ")"))))
    (println result)
    (println (length result))))


(define (test117)
    (letrec ((p (apply make-parser '("Start Date")))
           (result (p '("if" "(" "day" "of" "Start Date" ")" ">" "15" "then" "(" "set" "to" "first" "day" "of" "(" "set" "date" "to" "next" "month" "of" "Start Date" ")" ")" "else" "(" "set" "to" "first" "day" "of" "Start Date" ")"))))
    (println result)
    (println (length result))))

(define (test118)
      (letrec ((p (apply make-parser '("Start Date" "Term Date")))
           (result (p '("set" "date" "to" "1" "," "(" "round" "Term Date" "-" "Start Date" "/" "30" ")" "+" "1" "," "(" "year" "of" "Start Date" ")"))))
    (println result)
    (println (length result))))

(define (test119)
    (letrec ((p (apply make-parser '("Hourly overage" "Monthly overage" "Is_Valid" "Min servers" "Notes" "Pay_Cycle" "Pay_Method" "Price_Per_Server" "Price per server" "Terms" "Valid_From" "Valid_To" "agent_first_count" "agent_hwm" "agent_last_count" "agent_lwm" "average" "aws_lwm" "aws_first_count" "aws_hwm" "aws_last_count" "elapsed_hours" "first_count" "first_hour" "hwm" "last_count" "last_hour" "lwm" "server_hours" "std_dev" "top13" "top25" "top95p" "top99p" "std_plan_billable_hours" "MRR")))
           (result (p '("Price_Per_Server" "*" "Min servers" "top99p" "*" "Price_Per_Server" "plus" "Monthly overage"))))
    (println result)
    (println (length result))))

(define (test120)
    (letrec ((p (apply make-parser '("Start Date")))
           (result (p '("Start Date" "is" "in" "current" "month"))))
    (println result)
    (println (length result))))

(define (test121)
    (letrec ((p (apply make-parser '("Start Date")))
           (result (p '("Start Date" "is" "in" "most" "recent" "2" "months"))))
    (println result)
    (println (length result))))

(define (test122)
    (letrec ((p (apply make-parser '("Start Date" "End Date")))
           (result (p '("days360" "(" "Start Date" "," "End Date" ")"))))
    (println result)
    (println (length result))))

(define (test123)
    (letrec ((p (apply make-parser '("Terms" "Hourly overage")))
           (result (p '("Terms = Committed and 'Hourly overage'  is not null"))))
    (println result)
    (println (length result))))

(define (test124)
    (letrec ((p (apply make-parser '("Terms" "Hourly overage")))
           (result (p '("Terms" "is" "not" "equal" "to" "Committed" "and" "Terms" "is" "not" "equal" "to" "Standard"))))
    (println result)
    (println (length result))))