trackler 2.0.3.2 → 2.0.3.3

data/tracks/ocaml/tools/test-generator/src/template.ml

@@ -3,22 +3,65 @@ open Core.Std
 open Codegen
 open Utils
 
-(* start and finish are the lines where the generated code is *)
-type t = {start: int; finish: int; file_text: string; template: string} [@@deriving eq, show]
+(* start and finish are the lines where the generated code should be copied *)
+type t = {start: int;
+          finish: int;
+          file_text: string;
+          template: string;
+          suite_name_line: int option;
+          suite_end: int option;
+          suite_all_names_line: int option;
+         } [@@deriving eq, show]
 
 let find_template ~(template_text: string): t option =
   let open Option.Monad_infix in
   let str_contains pattern s = String.substr_index s ~pattern |> Option.is_some in
   let lines = String.split_lines template_text |> List.to_array in
-  let start_index = find_arrayi lines ~f:(str_contains "(* GENERATED-CODE") |> Option.map ~f:fst in
-  let finish_index = (start_index >>= (fun start -> find_arrayi ~start lines ~f:(str_contains "END GENERATED-CODE *"))) |> Option.map ~f:fst in
+  let suite_end = find_arrayi lines ~f:(str_contains "(* END SUITE *)") |> Option.map ~f:fst in
+  let start_index = find_arrayi lines ~f:(str_contains "(* TEST") |> Option.map ~f:fst in
+  let finish_index = (start_index >>= (fun start -> find_arrayi ~start lines ~f:(str_contains "END TEST *"))) |> Option.map ~f:fst in
   let template_lines = Option.map2 start_index finish_index (fun s -> Array.slice lines (s+1)) in
-  Option.map2 start_index template_lines ~f:(fun s l -> {start=s; finish=(s + 1 + Array.length l); file_text = template_text; template=String.concat_array l ~sep:"\n"})
+  let suite_name_line = find_arrayi lines ~f:(str_contains "(* SUITE *)$(suite_name)") |> Option.map ~f:fst in
+  let suite_all_names_line = find_arrayi lines ~f:(str_contains "(* suite-all-names *)") |> Option.map ~f:fst in
+  Option.map2 start_index template_lines ~f:(fun s l -> {start=s;
+                                                         finish=(s + 1 + Array.length l);
+                                                         file_text = template_text;
+                                                         template=String.concat_array l ~sep:"\n";
+                                                         suite_name_line = suite_name_line;
+                                                         suite_end = suite_end;
+                                                         suite_all_names_line = suite_all_names_line
+                                                        })
 
-let fill (template: t) (substs: subst list): string =
+let fill_tests (template: t) (substs: subst list): string =
   let lines = String.split_lines template.file_text |> List.to_array in
   let before = Array.slice lines 0 template.start in
   let subst = Array.of_list (List.map ~f:subst_to_string substs) in
   let after = Array.slice lines (template.finish + 1) (Array.length lines) in
   let join = String.concat_array ~sep:"\n" in
   String.concat [join before; join subst; join after] ~sep:"\n"
+
+(* HACKS HERE *)
+let fill_single_suite (template: t) (suite_substs: string * subst list): string =
+  let (suite_name, substs) = suite_substs in
+  let suite_name_line = Option.value_exn template.suite_name_line in
+  let suite_end_line = Option.value_exn template.suite_end in
+  let lines = String.split_lines template.file_text |> Fn.flip List.drop suite_name_line |> List.to_array in
+  Array.replace lines 0 ~f:(String.substr_replace_all ~pattern:"(* SUITE *)$(suite_name)_tests" ~with_:(suite_name ^ "_tests"));
+  let before = Array.slice lines 0 (template.start - suite_name_line) in
+  let subst = Array.of_list (List.map ~f:subst_to_string substs) in
+  let after = Array.slice lines (template.finish - suite_name_line + 1) (suite_end_line - suite_name_line) in
+  let join = String.concat_array ~sep:"\n" in
+  String.concat [join before; join subst; join after] ~sep:"\n"
+
+(* HACKS HERE *)
+let fill_suite (template: t) (suite_substs: (string * subst list) list): string =
+  let fills = List.map suite_substs ~f:(fun x -> (fill_single_suite template x) ^ "\n") in
+  let suite_name_line = Option.value_exn template.suite_name_line in
+  let lines = String.split_lines template.file_text |> List.to_array in
+  let before = Array.slice lines 0 suite_name_line in
+  let subst = Array.of_list fills in
+  let after = Array.slice lines (template.finish + 4) (Array.length lines) in
+  let join = String.concat_array ~sep:"\n" in
+  let generated = String.concat [join before; join subst; join after] ~sep:"\n" in
+  let all_suite_names = String.concat ~sep:"; " @@ List.map ~f:(fun (s,_) -> s ^ "_tests") suite_substs in
+  String.substr_replace_all generated ~pattern:"(* suite-all-names *)" ~with_:all_suite_names

data/tracks/ocaml/tools/test-generator/src/test_gen.ml

@@ -19,7 +19,7 @@ let command =
       +> flag "-c" (optional_with_default "../../../x-common/exercises" is_directory) ~doc:"string Directory containing canonical data."
       +> flag "-o" (optional_with_default "../../exercises" is_directory) ~doc:"string Directory to output generated tests."
     )
-    (fun templates_folder canonical_data_folder output_folder () -> Test_generator.run templates_folder canonical_data_folder output_folder)
+    (fun templates_folder canonical_data_folder output_folder () -> Controller.run templates_folder canonical_data_folder output_folder)
 
 let () =
   Command.run ~version:"0.1" command

data/tracks/ocaml/tools/test-generator/src/utils.ml

@@ -16,12 +16,18 @@ let to_list_option json =
 let to_list_note error json =
   try Ok (to_list json) with Type_error _ -> Error error
 
+let to_assoc_note error json =
+  try Ok (to_assoc json) with Type_error _ -> Error error
+
 let to_string_note error json =
   try Ok (to_string json) with Type_error _ -> Error error
 
 let safe_to_int_option json =
   try Some (to_int json) with Type_error _ -> None
 
+let member_note error m json =
+  try Ok (member m json) with Type_error _ -> Error error
+
 let (>>) f g = Fn.compose f g
 
 let find_arrayi ?start:(start = 0) xs ~f =

data/tracks/ocaml/tools/test-generator/templates/anagram/template.ml

@@ -7,10 +7,10 @@ let ae exp got _test_ctxt =
   assert_equal exp got ~cmp:(List.equal ~equal:String.equal) ~printer
 
 let tests = [
-(* GENERATED-CODE
+(* TEST
   "$description" >::
     ae $expected (anagrams "$subject" $candidates);
-   END GENERATED-CODE *)
+   END TEST *)
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/templates/bob/template.ml

@@ -5,10 +5,10 @@ open Bob
 let ae exp got _test_ctxt = assert_equal ~printer:String.to_string exp got
 
 let tests = [
-(* GENERATED-CODE
+(* TEST
    "$description" >::
       ae "$expected" (response_for "$input");
-   END GENERATED-CODE *)
+   END TEST *)
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/templates/bracket-push/template.ml

@@ -0,0 +1,16 @@
+open Core.Std
+open OUnit2
+open Bracket_push
+
+let ae exp got _test_ctxt =
+  assert_equal exp got ~printer:Bool.to_string
+
+let tests = [
+(* TEST
+  "$description" >::
+    ae $expected (are_balanced "$input");
+END TEST *)
+]
+
+let () =
+  run_test_tt_main ("bracket-push tests" >::: tests)

data/tracks/ocaml/tools/test-generator/templates/difference-of-squares/template.ml

@@ -0,0 +1,19 @@
+open Core.Std
+open OUnit2
+open Difference_of_squares
+
+let ae exp got _test_ctxt = assert_equal exp got
+
+let (* SUITE *)$(suite_name)_tests = [
+(* TEST
+   "$description" >::
+     ae $expected ($suite-name $number);
+   END TEST *)
+]
+(* END SUITE *)
+
+let () =
+  run_test_tt_main (
+    "difference of squares tests" >:::
+      List.concat [(* suite-all-names *)]
+  )

data/tracks/ocaml/tools/test-generator/templates/hamming/template.ml

@@ -20,10 +20,10 @@ let dna_of_string s =
 let hamdist a b = Hamming.hamming_distance (dna_of_string a) (dna_of_string b)
 
 let tests = [
-(* GENERATED-CODE
+(* TEST
    "$description" >::
       ae $expected (hamdist "$strand1" "$strand2");
-   END GENERATED-CODE *)
+   END TEST *)
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/templates/hello-world/template.ml

@@ -5,9 +5,9 @@ open Hello_world
 let ae exp got _test_ctxt = assert_equal ~printer:String.to_string exp got
 
 let tests = [
-  (* GENERATED-CODE
+  (* TEST
      "$description" >:: ae "$expected" (greet $name);
-     END GENERATED-CODE *)
+     END TEST *)
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/templates/leap/template.ml

@@ -5,10 +5,10 @@ open Leap
 let ae exp got _test_ctxt = assert_equal exp got
 
 let tests = [
-(* GENERATED-CODE
+(* TEST
   "$description" >::
     ae $expected (leap_year $input);
-END GENERATED-CODE *)
+END TEST *)
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/templates/raindrops/template.ml

@@ -5,10 +5,10 @@ open Raindrops
 let ae exp got _test_ctxt = assert_equal ~printer:Fn.id exp got
 
 let tests = [
-(* GENERATED-CODE
+(* TEST
    "$description" >::
       ae "$expected" (raindrop $number);
-   END GENERATED-CODE *)
+   END TEST *)
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/templates/say/template.ml

@@ -5,11 +5,11 @@ open Say
 let ae exp got _ctx = assert_equal ~printer:(Option.value ~default:"None") exp got
 
 let tests = [
-(* GENERATED-CODE
+(* TEST
    "$description" >:: (
       ae $expected
-         (in_english $(input)L));
-   END GENERATED-CODE *)
+         (in_english $input));
+   END TEST *)
   "all numbers from 1 to 10_000 can be spelt">::(fun _ ->
       assert_bool "range test" (Sequence.range 0 10_000
                                 |> Sequence.map ~f:(fun n -> Int64.of_int n |> in_english)

data/tracks/ocaml/tools/test-generator/templates/word-count/template.ml

@@ -9,11 +9,11 @@ let ae exp got _test_ctxt =
   assert_equal (SMap.of_alist_exn exp) got ~cmp:(SMap.equal (=)) ~printer
 
 let tests = [
-(* GENERATED-CODE
+(* TEST
    "$description" >::
       ae $expected
          (word_count "$input");
-   END GENERATED-CODE *)
+   END TEST *)
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/test/all_tests.ml

@@ -8,4 +8,6 @@ open Template_test
 open Utils_test
 
 let () =
-  run_test_tt_main ("tests" >:::List.concat [codegen_tests; model_tests; parser_tests; special_cases_tests; template_tests; utils_tests])
+  run_test_tt_main ("tests" >:::List.concat [
+      codegen_tests; model_tests; parser_tests;
+      special_cases_tests; template_tests; utils_tests])

data/tracks/ocaml/tools/test-generator/test/codegen_test.ml

@@ -5,19 +5,19 @@ open Model
 
 let leap_template = "\"$description\" >:: ae $expected (leap_year $input);"
 
-let fixup ~key ~value = parameter_to_string value
-let edit = Fn.id
-let assert_gen exp cases = assert_equal exp
+let edit_expected ~value = parameter_to_string value
+let edit_parameters = Fn.id
+let assert_fill_in_template exp cases = assert_equal exp
     ~printer:(fun xs -> "[" ^ (String.concat ~sep:";" xs) ^ "]")
-    (Result.ok_or_failwith @@ generate_code fixup edit leap_template cases |> List.map ~f:subst_to_string)
-let ae exp cases _test_ctxt = assert_gen exp cases
+    (fill_in_template edit_expected edit_parameters leap_template "suite-name" cases |> List.map ~f:subst_to_string)
+let ae exp cases _test_ctxt = assert_fill_in_template exp cases
 
 let codegen_tests = [
   "if there are no cases then generate an empty string" >::
-    ae [] [];
+  ae [] [];
 
   "generates one function based on leap year for one case" >::(fun ctxt ->
       let c = {description = "leap_year"; parameters = [("input", Int 1996)]; expected = Bool true} in
-      assert_gen ["\"leap_year\" >:: ae true (leap_year 1996);"] [c]
+      assert_fill_in_template ["\"leap_year\" >:: ae true (leap_year 1996);"] [c]
     );
 ]

data/tracks/ocaml/tools/test-generator/test/difference_of_squares.json

@@ -0,0 +1,67 @@
+{
+    "square_of_sum": {
+        "description": ["Square the sum of the numbers up to the given number"],
+        "cases": [
+            {
+                "description": "square of sum 5",
+                "number": 5,
+                "expected": 225
+            },
+            {
+                "description": "square of sum 10",
+                "number": 10,
+                "expected": 3025
+            },
+            {
+                "description": "square of sum 100",
+                "number": 100,
+                "expected": 25502500
+            }
+        ]
+    },
+    "sum_of_squares": {
+        "description": ["Sum the squares of the numbers up to the given number"],
+        "cases": [
+            {
+                "description": "sum of squares 5",
+                "number": 5,
+                "expected": 55
+            },
+            {
+                "description": "sum of squares 10",
+                "number": 10,
+                "expected": 385
+            },
+            {
+                "description": "sum of squares 100",
+                "number": 100,
+                "expected": 338350
+            }
+        ]
+    },
+    "difference_of_squares": {
+        "description": ["Subtract sum of squares from square of sums"],
+        "cases": [
+            {
+                "description": "difference of squares 0",
+                "number": 0,
+                "expected": 0
+            },
+            {
+                "description": "difference of squares 5",
+                "number": 5,
+                "expected": 170
+            },
+            {
+                "description": "difference of squares 10",
+                "number": 10,
+                "expected": 2640
+            },
+            {
+                "description": "difference of squares 100",
+                "number": 100,
+                "expected": 25164150
+            }
+        ]
+    }
+}

data/tracks/ocaml/tools/test-generator/test/hello_world.json

@@ -0,0 +1,23 @@
+{
+   "#": [
+     "Language implementations vary on the issue of missing input variables.",
+     "In this set of test cases, the input variable is left out of the definition,",
+     "and the generator would need to handle the language implementation."
+   ],
+   "cases": [
+      {
+         "description": "no name",
+         "expected": "Hello, World!"
+      },
+      {
+         "description": "sample name",
+         "name": "Alice",
+         "expected": "Hello, Alice!"
+      },
+      {
+         "description": "other sample name",
+         "name": "Bob",
+         "expected": "Hello, Bob!"
+      }
+   ]
+}

data/tracks/ocaml/tools/test-generator/test/parser_test.ml

@@ -4,17 +4,20 @@ open Parser
 open Model
 
 let show_cases = function
-  | Ok cs -> List.map ~f:show_case cs |> String.concat
+  | Ok (Single cs) -> List.map ~f:show_case cs |> String.concat
+  | Ok (Suite cs) -> failwith "no printer"
   | Error e -> show_error e
 
 let ae exp got _test_ctxt = assert_equal exp got ~printer:show_cases
 
+let single x = Ok (Single x)
+
 let parser_tests = [
   "parses empty json as empty list" >::
-    ae (Ok []) (parse_json_text "{\"cases\" : []}");
+    ae (single []) (parse_json_text "{\"cases\" : []}");
 
   "gives an error with a json map that does not have the key cases in" >::
-    ae (Error TopLevelMustHaveKeyCalledCases)
+    ae (Error UnrecognizedJson)
        (parse_json_text "{\"case\" : [{\"description\" : \"d1\", \"expected\" : 100}]}");
 
   "gives an error with cases that is not a json list" >::
@@ -26,27 +29,27 @@ let parser_tests = [
        (parse_json_text "{\"cases\" : [\"key\"]}");
 
   "parses a single element with a description and expected string output" >::
-    ae (Ok [{description = "d1"; parameters = []; expected = String "value"}])
+    ae (single [{description = "d1"; parameters = []; expected = String "value"}])
        (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : \"value\"}]}");
 
   "parses a single element with a description and expected float output" >::
-    ae (Ok [{description = "d1"; parameters = []; expected = Float 100.}])
+    ae (single [{description = "d1"; parameters = []; expected = Float 100.}])
        (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : 100.0}]}");
 
   "parses a single element with a description and expected bool output" >::
-    ae (Ok [{description = "d1"; parameters = []; expected = Bool true}])
+    ae (single [{description = "d1"; parameters = []; expected = Bool true}])
       (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : true}]}");
 
   "parses a single element with an int key value pair" >::
-    ae (Ok [{description = "d1"; parameters = [("input", Int 1996)]; expected = Bool true}])
+    ae (single [{description = "d1"; parameters = [("input", Int 1996)]; expected = Bool true}])
       (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"input\" : 1996, \"expected\" : true}]}");
 
   "parses a single element with a string key value pair" >::
-    ae (Ok [{description = "d1"; parameters = [("input", String "some-string")]; expected = Int 85}])
+    ae (single [{description = "d1"; parameters = [("input", String "some-string")]; expected = Int 85}])
       (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"input\" : \"some-string\", \"expected\" : 85}]}");
 
   "parses a single element with a string list key value pair" >::
-    ae (Ok [{description = "d1"; parameters = [("input", StringList ["s1"; "s2"])]; expected = Int 85}])
+    ae (single [{description = "d1"; parameters = [("input", StringList ["s1"; "s2"])]; expected = Int 85}])
       (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"input\" : [\"s1\", \"s2\"], \"expected\" : 85}]}");
 
   "an element without a description is an Error" >::
@@ -62,13 +65,28 @@ let parser_tests = [
       (parse_json_text "{\"cases\" : [{\"input\" : 11}]}");
 
   "parses a map in the expected parameter" >::(fun _ctx ->
-      assert_equal (Ok [{description = "d1"; parameters = []; expected = IntStringMap [("one", 1); ("two", 2)]}])
+      assert_equal (single [{description = "d1"; parameters = []; expected = IntStringMap [("one", 1); ("two", 2)]}])
         (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : {\"one\": 1, \"two\": 2}}]}");
       );
 
   "parses leap.json" >::(fun ctxt ->
       match parse_json_text @@ In_channel.read_all "test/leap.json" with
-      | Ok p -> assert_equal 7 (List.length p)
-      | _ -> failwith "failed to parse leap.json"
+      | Ok (Single p) -> assert_equal 7 (List.length p)
+      | Ok (Suite p) -> assert_failure "was suite"
+      | Error e -> assert_failure ("failed to parse leap.json: " ^ show_error e)
   );
+
+  "parses hello_world.json which has a # element as documentation" >::(fun ctxt ->
+      match parse_json_text @@ In_channel.read_all "test/hello_world.json" with
+      | Ok (Single p) -> ()
+      | Ok (Suite p) -> assert_failure "was suite"
+      | Error e -> assert_failure ("failed to parse hello_world.json: " ^ show_error e)
+    );
+
+  "parses difference_of_squares.json" >::(fun ctxt ->
+      match parse_json_text @@ In_channel.read_all "test/difference_of_squares.json" with
+      | Ok (Suite p) -> assert_equal ["square_of_sum"; "sum_of_squares"; "difference_of_squares"] (List.map ~f:(fun x -> x.name) p)
+      | Ok (Single p) -> assert_failure "was single"
+      | Error e -> assert_failure ("failed to parse difference_of_squares.json: " ^ show_error e)
+    );
 ]