(**************************************************************************
 * You can add new test cases by adding new elements to the following lists
 * Format is:
 * TEST<X>ARG(<weight>, <function_name>, <arg1>, <arg2>, ..., <argX>)
 *
 * <X> is the number of argument that the function being tested takes.
 **************************************************************************)
open Mp3common

(* ====== Specific normalize versions of our code and the students code =====*)
let freeVarsInExp_stu e = Mp3common.mergesort (Student.freeVarsInExp e)
let freeVarsInExp_sol e = Mp3common.mergesort (Solution.freeVarsInExp e)

let cps_exp_stu e k =
    let ec = Student.cps_exp e k
    in Mp3common.exp_cps_normalize ec (Solution.freeVarsInExp e) 
let cps_exp_sol e k =
    let ec = Solution.cps_exp e k
    in Mp3common.exp_cps_normalize ec (Solution.freeVarsInExp e)

(*=========================Some complex test values=======================*)
let ackermann =
LetRecInExp("a", "b",
 IfExp(BinOpAppExp(GreaterOp,VarExp "b", ConstExp(IntConst 1)),
   LetInExp("c", AppExp(VarExp "a",
                       BinOpAppExp(IntMinusOp, VarExp "b", ConstExp(IntConst 1))),
            LetInExp("d", AppExp(VarExp "a",
                                 BinOpAppExp(IntMinusOp, VarExp "b", ConstExp(IntConst 2))),
                     BinOpAppExp(IntPlusOp, VarExp "c", VarExp "d"))),
   ConstExp(IntConst 1)),
   AppExp(VarExp "a", ConstExp(IntConst 12)))

let e =
LetRecInExp("a","b",FunExp("i",IfExp(BinOpAppExp(EqOp,VarExp "i", ConstExp(IntConst 0)),
    ConstExp(BoolConst true),
    AppExp(VarExp "b", BinOpAppExp(IntMinusOp,VarExp "i", ConstExp(IntConst 1))))),
    LetRecInExp("b","i", IfExp(BinOpAppExp(EqOp,VarExp "i", ConstExp(IntConst 0)),
    ConstExp(BoolConst false),
    AppExp(AppExp(VarExp "a", VarExp "b"),
          BinOpAppExp(IntMinusOp,VarExp "i", ConstExp(IntConst 1)))),
    VarExp "b"))

let k0 = ContVarCPS Kvar
let k1 = FnContCPS ("a", FunCPS(ContVarCPS Kvar, "b", Kvar,
                  AppCPS(ContVarCPS Kvar, "a", "b")))
let k2 = FnContCPS ("b", FunCPS(ContVarCPS Kvar, "b", Kvar,
                  AppCPS(ContVarCPS Kvar, "a", "b")))


(* This list is for regular problems *)
let rubric =
[
  TEST1ARG(1, import_list, [(7,1);(4,2);(6,3)]);
  TEST1ARG(1, import_list, []);
  TEST1ARG(2, import_list, [(12,10000000);(0,-2);((-7),-10000000);(22,10000000);(0,2);(59,101000)]);
 
  TEST0ARG(4, pair_sums);
(*
  TEST0ARG(1, (evalAll (Student.list_all) (Solution.list_all)));
  TEST0ARG(1, (evalAllB (Student.list_all) (Solution.list_all)));
  TEST0ARG(1, (evalAllC (Student.list_all) (Solution.list_all)));
*)

  TEST1ARG(1, count_const_in_exp,  (BinOpAppExp (CommaOp,
 BinOpAppExp (CommaOp, ConstExp (FloatConst 7.3), ConstExp UnitConst),
 BinOpAppExp (ConsOp,
  BinOpAppExp (CommaOp, ConstExp (IntConst 4), ConstExp (StringConst "a")),
  BinOpAppExp (ConsOp,
   BinOpAppExp (CommaOp, ConstExp (IntConst 6), ConstExp (StringConst "b")),
   ConstExp NilConst)))));
  TEST1ARG(1, count_const_in_exp, (VarExp "a"));
  TEST1ARG(1, count_const_in_exp, (ConstExp (IntConst 5)));
  TEST1ARG(1, count_const_in_exp, (IfExp (BinOpAppExp(EqOp, VarExp "a", ConstExp (StringConst "b")), MonOpAppExp(HdOp, AppExp(VarExp "ww", ConstExp NilConst)), FunExp("x", VarExp "a"))));
  TEST1ARG(1, count_const_in_exp, (LetRecInExp("g","w",VarExp "q", LetInExp("a", ConstExp UnitConst,
AppExp(AppExp(VarExp "g", VarExp "a"), VarExp "d")))));

  TEST1ARG(1, freeVarsInExp, (VarExp "x"));
  TEST1ARG(1, freeVarsInExp, (ConstExp NilConst));

  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (IfExp(VarExp "a",VarExp "b",VarExp "c")));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (IfExp(AppExp(VarExp "a",VarExp "b"),VarExp "c",VarExp "f")));

  TEST1ARG(1, freeVarsInExp, (MonOpAppExp (TlOp, VarExp "v")));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (MonOpAppExp (IntNegOp, BinOpAppExp (ConcatOp, VarExp "fg", VarExp "yz"))));

  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (BinOpAppExp (CommaOp, VarExp "v", VarExp "dv")));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (BinOpAppExp (ConsOp, MonOpAppExp (TlOp, VarExp "v"), MonOpAppExp (TlOp, VarExp "w"))));

  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (AppExp(VarExp "d",VarExp "e")));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (AppExp(VarExp "d",IfExp(BinOpAppExp(GreaterOp, VarExp "silly", ConstExp (BoolConst true)), VarExp "x", VarExp "y"))));


  TEST1ARG(1, freeVarsInExp, (FunExp("x", VarExp "x")));
  TEST1ARG(1, freeVarsInExp, (FunExp("x", VarExp "y")));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (AppExp(FunExp("x", FunExp("z",AppExp(VarExp "y", VarExp "z"))), VarExp "x")));

  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (LetInExp("x", VarExp "y", VarExp "x")));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (LetInExp("x", VarExp "x", VarExp "x")));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu, (LetInExp("x", VarExp "y", VarExp "y")));

  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu,
                  (LetRecInExp("f","x",AppExp(VarExp "f",VarExp "x"),
                               AppExp(VarExp "f",VarExp "y"))));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu,
                  (LetRecInExp("f","x",AppExp(VarExp "f",VarExp "x"),
                               AppExp(VarExp "f",VarExp "x"))));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu,
                  LetRecInExp ("f", "x", BinOpAppExp(IntPlusOp, VarExp "x",
                                         AppExp(VarExp  "f", VarExp "y")),
                  AppExp(VarExp  "f", ConstExp(IntConst 0))));
  TEST1ARG_TWOFUN(1, freeVarsInExp_sol, freeVarsInExp_stu,
                  LetRecInExp ("f", "x", BinOpAppExp(IntPlusOp, VarExp "x",
                                         AppExp(VarExp  "f", VarExp "y")),
                  AppExp(VarExp  "g", ConstExp(IntConst 0))));


  TEST2ARG(1, cps_exp, (VarExp "x"), (ContVarCPS Kvar));
  TEST2ARG(1, cps_exp, (VarExp "y"), External);
  TEST2ARG(1, cps_exp, (ConstExp (StringConst "x")), (ContVarCPS Kvar));
  TEST2ARG(1, cps_exp, (ConstExp (BoolConst true)), k1);

  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, (IfExp (VarExp "b", ConstExp (IntConst 2),
                                         ConstExp (IntConst 5))),
                                 (ContVarCPS Kvar));
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, 
                  (IfExp (ConstExp(BoolConst false), VarExp "a", VarExp "b")),
                                 k1);
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
                  (IfExp (IfExp(VarExp "b", ConstExp (IntConst 2),
                          ConstExp (IntConst 5)),
                             IfExp (ConstExp(BoolConst false), VarExp "a",
                                         VarExp "aa"),
                               IfExp(VarExp "e", ConstExp (FloatConst 5.5),
                                         VarExp "c"))),
                                 k0);

  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, (AppExp (VarExp "f", VarExp "x")),
                         (ContVarCPS Kvar));
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
              (AppExp(AppExp(VarExp "a", ConstExp UnitConst), VarExp "c")), k2);
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
              (AppExp(AppExp(VarExp "b", ConstExp UnitConst), VarExp "c")), k1);

  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, (BinOpAppExp (IntPlusOp, ConstExp(IntConst 5),
                                              ConstExp(IntConst 1))),
                          (ContVarCPS Kvar));
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
  (BinOpAppExp(ConcatOp, BinOpAppExp(IntMinusOp, VarExp "a", VarExp "b"),
              VarExp "c")), k2);
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
  (BinOpAppExp(ConsOp,BinOpAppExp(CommaOp,VarExp "b", ConstExp UnitConst),
               VarExp "a")), k1);

  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, (MonOpAppExp (HdOp, ConstExp NilConst)),
                                  (ContVarCPS Kvar));
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
                  (MonOpAppExp (TlOp, VarExp "b")), k2);
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
                  (MonOpAppExp (SndOp, VarExp "a")), k1);

  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, (FunExp ("x", VarExp "x")), (ContVarCPS Kvar));
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
   (FunExp ("a", ConstExp (IntConst 2))), k0);
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, (FunExp ("a", VarExp "a")), k2);

  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
                  (LetInExp ("x", ConstExp(IntConst 2), VarExp "x")),
                      (ContVarCPS Kvar));
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,LetInExp("x", VarExp "y", VarExp "x"), k1);
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu,
   (LetInExp ("a", VarExp "a", LetInExp("b", AppExp(VarExp "a", VarExp "b"),
            BinOpAppExp(ConsOp, VarExp "b", AppExp(VarExp "a", VarExp "c"))))), k0)

]


let extra_rubric = [ 
  TEST2ARG(1, cps_exp, (LetRecInExp ("f", "x",VarExp "x",
                                  ConstExp (IntConst 4))),
                                 (ContVarCPS Kvar));
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, ackermann, External);
  TEST2ARG_TWOFUN(1, cps_exp_sol, cps_exp_stu, e, (FnContCPS("b",AppCPS(k1,"a","b"))))
]