(* dir_unittest.ml - Don Yang (uguu.org)

   04/23/06
                                                                           *)

(* Check test input files and directories *)
let data_file = "dir_unittest.cmx";;
let tmp_dir = "dir_unittest.tmp";;

if not (Sys.file_exists data_file)
then failwith (data_file ^ " not found");;

if Sys.file_exists tmp_dir
then failwith ("Need to delete " ^ tmp_dir ^ " before running test");;

(* Test Dir.insert_dependents *)
let test_cases =
[
   ([], []);
   (["a"], ["a"]);
   (["a"; "a"], ["a"]);

   (["a/b"],         ["a"; "a/b"]);
   (["a/b"; "a"],    ["a"; "a/b"]);
   (["a"; "a/b"],    ["a"; "a/b"]);
   (["a/b"; "a/b"],  ["a"; "a/b"]);

   (["a/b/c"],                   ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a"],              ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a/b"],            ["a"; "a/b"; "a/b/c"]);
   (["a"; "a/b/c"],              ["a"; "a/b"; "a/b/c"]);
   (["a/b"; "a/b/c"],            ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a/b/c"],          ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a"; "a"],         ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a"; "a/b"],       ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a/b"; "a"],       ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a/b"; "a/b"],     ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a/b/c"; "a/b"],   ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a/b"; "a/b/c"],   ["a"; "a/b"; "a/b/c"]);
   (["a"; "a"; "a/b/c"],         ["a"; "a/b"; "a/b/c"]);
   (["a"; "a/b"; "a/b/c"],       ["a"; "a/b"; "a/b/c"]);
   (["a/b"; "a"; "a/b/c"],       ["a"; "a/b"; "a/b/c"]);
   (["a/b"; "a/b"; "a/b/c"],     ["a"; "a/b"; "a/b/c"]);
   (["a/b/c"; "a/b"; "a/b/c"],   ["a"; "a/b"; "a/b/c"]);
   (["a/b"; "a/b/c"; "a/b/c"],   ["a"; "a/b"; "a/b/c"]);

   (["a"; "b"], ["a"; "b"]);
   (["b"; "a"], ["a"; "b"]);

   (["a/b/c"; "a/b/d"], ["a"; "a/b"; "a/b/c"; "a/b/d"]);
   (["a/b/c"; "a/d/e"], ["a"; "a/b"; "a/b/c"; "a/d"; "a/d/e"]);
   (["a/b/c"; "d/e/f"], ["a"; "a/b"; "a/b/c"; "d"; "d/e"; "d/e/f"]);
   (["d/e/f"; "a/b/c"], ["a"; "a/b"; "a/b/c"; "d"; "d/e"; "d/e/f"]);
];;
List.iter
   (fun item ->
      List.iter Path.replace_separator (fst item);
      List.iter Path.replace_separator (snd item))
   test_cases;;
List.iter
   (fun item ->
      if Dir.insert_dependents (fst item) <> (snd item)
      then failwith "Dir.insert_dependents")
   test_cases;;

(* Test Dir.create_forest and Dir.enumerate *)
let compare_list_item label a b =
   if a <> b then failwith (label ^ ": " ^ a ^ ", " ^ b);;

let input_dirs =
[
   tmp_dir ^ "/a/b/c";
   tmp_dir ^ "/d/e/f";
   tmp_dir ^ "/a/b/d";
   tmp_dir ^ "/g";
];;
let output_dirs =
[
   tmp_dir ^ "/a";
   tmp_dir ^ "/a/b";
   tmp_dir ^ "/a/b/c";
   tmp_dir ^ "/a/b/d";
   tmp_dir ^ "/d";
   tmp_dir ^ "/d/e";
   tmp_dir ^ "/d/e/f";
   tmp_dir ^ "/g";
];;
List.iter Path.replace_separator input_dirs;;
List.iter Path.replace_separator output_dirs;;
Dir.create_forest input_dirs;;
let test_output =
   List.sort compare
      (List.map (fun x -> fst x) (Dir.enumerate tmp_dir)) in
List.iter2
   (compare_list_item "Dir.create_forest")
   output_dirs test_output;;

(* Test Dir.enumerate and Dir.split_file_list *)
let output_files =
   List.flatten
      (List.map
         (fun x -> [x ^ Path.separator_str ^ "00_file_a";
                    x ^ Path.separator_str ^ "00_file_b"])
         output_dirs);;
List.iter (fun x -> File.copy data_file x) output_files;;
let test_dirs, test_files =
   Dir.split_file_list (Dir.enumerate tmp_dir) in
   List.iter2
      (compare_list_item "Dir.enumerate / Dir.split_file_list")
      (List.sort compare test_dirs)
      output_dirs;
   List.iter2
      (compare_list_item "Dir.enumerate / Dir.split_file_list")
      (List.sort compare (List.map (fun x -> fst x) test_files))
      output_files;;

(* Test Dir.enumerate_no_recurse *)
let flat_output_dirs =
[
   tmp_dir ^ "/a";
   tmp_dir ^ "/d";
   tmp_dir ^ "/g";
];;
List.iter Path.replace_separator flat_output_dirs;;
let flat_output_files = [];;
let test_dirs, test_files =
   Dir.split_file_list (Dir.enumerate_no_recurse tmp_dir) in
   List.iter2
      (compare_list_item "Dir.enumerate_no_recurse / Dir.split_file_list")
      (List.sort compare test_dirs)
      flat_output_dirs;
   List.iter2
      (compare_list_item "Dir.enumerate_no_recurse / Dir.split_file_list")
      (List.sort compare (List.map (fun x -> fst x) test_files))
      flat_output_files;;

(* Cleanup *)
List.iter (fun x -> Unix.unlink x) output_files;;
List.iter (fun x -> Unix.rmdir x) (List.rev output_dirs);;
Unix.rmdir tmp_dir;;

print_string "PASS\n";;