(**************************************************************************
 * 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 Mp4common

let odd_sum_stu l = List.fold_right Student.odd_sum_rec l Student.odd_sum_base
let odd_sum_sol l = List.fold_right Solution.odd_sum_rec l Solution.odd_sum_base

let count_element_stu l m = List.fold_left (Student.count_element_rec m) Student.count_element_base l
let count_element_sol l m = List.fold_left (Solution.count_element_rec m) Solution.count_element_base l

let idk = fun x -> x
let uk = fun x -> ()



(* This list is for regular problems *)
let rubric =
[
  TEST1ARG(1, pair_sums_map, [(1,6);(3,1);(3,2)]);
  TEST1ARG(1, pair_sums_map, []);
  TEST1ARG(1, pair_sums_map, [(4,(-1))]);
  TEST1ARG(1, pair_sums_map, [(0,0); (17, 34); (22,(-17)); ((-4),(-19))]);

  TEST1ARG_TWOFUN(1, odd_sum_sol, odd_sum_stu, [1;2;3]);
  TEST1ARG_TWOFUN(1, odd_sum_sol, odd_sum_stu, []);
  TEST1ARG_TWOFUN(1, odd_sum_sol, odd_sum_stu, [-15]);
  TEST1ARG_TWOFUN(1, odd_sum_sol, odd_sum_stu, [14;15]);
  TEST1ARG_TWOFUN(1, odd_sum_sol, odd_sum_stu, [2;4;6;8;10;1;3;5;7;9;11;13;15]);

  TEST2ARG_TWOFUN(1, count_element_sol, count_element_stu, [0;1;3;2;1;1;3], 3);
  TEST2ARG_TWOFUN(1, count_element_sol, count_element_stu, [], 3);
  TEST2ARG_TWOFUN(1, count_element_sol, count_element_stu, ["a"], "a");
  TEST2ARG_TWOFUN(1, count_element_sol, count_element_stu, ["c";"d";"h"], "a");
  TEST2ARG_TWOFUN(1, count_element_sol, count_element_stu, ["c";"d";"h"], "d");


  TEST3ARG(1, divk, 12, 5, (fun x -> (report x; x)));
  TEST3ARG(0, modk, 1, 1, (fun x -> x));
  TEST3ARG(1, catk, "hello ", "world", (fun x -> x));
  TEST3ARG(1, float_subk, 3.0, 1.0,
      (fun x -> Solution.float_mulk x 2.0
        (fun y -> (print_string "Result: ";print_float y; print_newline(); y))));
  TEST3ARG(1, leqk, 2, 1, (fun b -> (report (if b then 1 else 0))));

  TEST3ARG(0, divk, 1, 1, (fun x -> x));
  TEST3ARG(0, float_subk, 1.0, 1.0, (fun x -> x));
  TEST3ARG(1, float_mulk, 1.0, 1.0, (fun x -> x));
  TEST3ARG(0, catk, "a", "b", (fun x -> x));
  TEST3ARG(1, consk, 1, [], (fun x -> x));
  TEST3ARG(0, consk, 1.0, [], (fun x -> x));
  TEST3ARG(0, leqk, 1, 1, (fun x -> x));
  TEST3ARG(0, leqk, 1.0, 1.0, (fun x -> x));
  TEST3ARG(0, eqk, 1, 1, (fun x -> x));
  TEST3ARG(0, eqk, 1.0, 1.0, (fun x -> x));

  TEST3ARG(0, divk, 1, 1, (fun x -> ()));
  TEST3ARG(0, modk, 1, 1, (fun x -> ()));
  TEST3ARG(0, float_subk, 1.0, 1.0, (fun x -> ()));
  TEST3ARG(0, float_mulk, 1.0, 1.0, (fun x -> ()));
  TEST3ARG(0, catk, "a", "b", (fun x -> ()));
  TEST3ARG(0, consk, 1, [], (fun x -> ()));
  TEST3ARG(0, consk, 1.0, [], (fun x -> ()));
  TEST3ARG(0, leqk, 1, 1, (fun x -> ()));
  TEST3ARG(0, leqk, 1.0, 1.0, (fun x -> ()));
  TEST3ARG(0, eqk, 1, 1, (fun x -> ()));
  TEST3ARG(0, eqk, 1.0, 1.0, (fun x -> ()));

  TEST2ARG(1, poly, 2, (fun x -> (report x; x)));
  TEST2ARG(1, poly, 0, (fun x -> (report x; x)));
  TEST2ARG(1, poly, 1, (fun x -> (report x; x)));
  TEST2ARG(1, poly, -1, (fun x -> (report x; x)));
  TEST2ARG(1, poly, 10, (fun x -> (report x; x)));
  TEST2ARG(0, poly, 2, (fun x -> x));
  TEST2ARG(0, poly, 2, (fun x -> ()));

  TEST5ARG(1, distributek, Solution.inck, Solution.addk, 1, 2, (fun x -> x));
  TEST5ARG(0, distributek, Solution.inck, Solution.addk, 1, 2, (fun x -> ()));
  TEST5ARG(1, distributek, (fun x -> fun k -> k (x = 1)), (fun x -> fun y -> fun k -> k (x = y)), 1, 2, (fun x -> x));
  TEST5ARG(0, distributek, (fun x -> fun k -> k (x = 1)), (fun x -> fun y -> fun k -> k (x = y)), 1, 2, (fun x -> ()));
  TEST5ARG(0, distributek, (fun x -> fun k -> k ()), (fun x -> fun y -> fun k -> k 0.0), (), (), (fun x -> x));
  TEST5ARG(0, distributek, (fun x -> fun k -> k ()), (fun x -> fun y -> fun k -> k 0.0), (), (), (fun x -> ()));
  TEST5ARG(6, distributek, (fun x -> fun k -> k(x ^ "a")), (fun y -> fun z -> fun k -> k (z^y^z)), "c", "d", (fun x -> x));

  TEST1ARG(1, alternate_series, 10);
  TEST1ARG(1, alternate_series, (-10));
  TEST2ARG(1, alternate_seriesk, 10, (fun x -> x));
  TEST2ARG(0, alternate_seriesk, 10, (fun x -> ()));
  TEST2ARG(1, alternate_seriesk, (-10), (fun x -> x));
  TEST2ARG(1, alternate_seriesk, 0, (fun x -> x));
  TEST2ARG(1, alternate_seriesk, 1, (fun x -> x));

  TEST2ARG(2, rev_iter, (fun x -> print_int x), [1;2;3;4;5]);
  TEST2ARG(0, rev_iter, (fun x -> ()), [true;false]);
  TEST3ARG(5, rev_iterk, (fun x -> fun k -> Solution.print_intk x (fun t -> k t)), [1;2;3;4;5], (fun x -> x));
  TEST3ARG(0, rev_iterk, (fun x -> fun k -> Solution.print_intk x (fun t -> k t)), [1;2;3;4;5], (fun x -> ()));
  TEST3ARG(0, rev_iterk, (fun x -> fun k -> k ()), [true;false], (fun x -> x));
  TEST3ARG(0, rev_iterk, (fun x -> fun k -> k ()), [true;false], (fun x -> ()));

  TEST2ARG(1, filter, [1;2;3;4;5], (fun x -> x >= 3));
  TEST2ARG(1, filter, ["a";"";"c";"";"es"], (fun x -> String.length x > 0));
  TEST2ARG(0, filter, [true;false], (fun x -> not x));
  TEST3ARG(1, filterk, [1;2;3;4;5], (fun x -> fun k -> Solution.leqk x 3 k), (fun x -> x));
  TEST3ARG(2, filterk, ["a";"";"c";"";"es"], (fun x -> fun k -> k(String.length x > 0)), (fun x -> x));
  TEST3ARG(1, filterk, [], (fun x -> fun k -> k x), (fun x -> x));
  TEST3ARG(0, filterk, [1;2;3;4;5], (fun x -> fun k -> Solution.leqk x 3 k), (fun x -> ()));
  TEST3ARG(2, filterk, [true;false], (fun x -> fun k -> k (not x)), (fun x -> x));
  TEST3ARG(0, filterk, [true;false], (fun x -> fun k -> k (not x)), (fun x -> ()))
(*;

  TEST4ARG(1, assock, [(1, "a") ; (2, "b")  ;(3, "c") ;(4, "d")], (fun x -> fun k -> Solution.eqk x 3 k), (fun x -> x), (fun x -> print_string "key not found!"; ""));
  TEST4ARG(1, assock, [(1, "a") ; (2, "b")  ;(3, "c") ;(4, "d")], (fun x -> fun k -> Solution.eqk x 6 k), (fun x -> x), (fun x -> print_string "key not found!"; ""));
  TEST4ARG(0, assock, [(true, 1);(false, 0)], (fun x -> fun k -> k (not x)), (fun x -> ()), (fun x -> print_string "key not found!"; x));
  TEST4ARG(0, assock, [(true, 1); (true, 0)], (fun x -> fun k -> k (not x)), (fun x -> ()), (fun x -> print_string "key not found!"; x))
*)
]
(* 




*)

(* Note: the last entry should not be followed by a semicolon. *)

let extra_rubric = [ 
  TEST3ARG(1, apply_even_odd, [1;2;3], (fun x -> x + 1), (fun x -> x - 1));
  TEST3ARG(1, apply_even_odd, [(1, 1);(15, 7)], (fun (x, y) -> x + y), (fun (x, y) -> x - y));
  TEST3ARG(1, apply_even_odd, [], (fun x -> ()), (fun y -> ()));

  TEST3ARG(2, appk, [Solution.inck;Solution.inck;Solution.inck], 0, (fun x -> x));
  TEST3ARG(2, appk, [Solution.notk;Solution.notk;Solution.notk], false, (fun x -> x));
  TEST3ARG(1, appk, [], "a", (fun x -> x));
  TEST3ARG(3, appk, [Solution.catk "a"; Solution.catk "b"; Solution.catk "c"], "e", (fun x -> x))
]