trackler 2.0.3.8 → 2.0.3.9

data/tracks/ocaml/exercises/robot-name/.merlin

@@ -0,0 +1,3 @@
+S *
+B _build/**
+PKG core oUnit

data/tracks/ocaml/exercises/robot-name/Makefile

@@ -0,0 +1,11 @@
+test: test.native
+	@./test.native
+
+test.native: *.ml *.mli
+	@corebuild -r -quiet -pkg oUnit test.native
+
+clean:
+	rm -rf _build
+	rm -f test.native
+
+.PHONY: clean

data/tracks/ocaml/exercises/robot-name/example.ml

@@ -0,0 +1,26 @@
+open Core.Std
+
+type robot = {mutable index : int}
+
+let index = ref (-1)
+
+let unique_ids: int array =
+  let ids = Array.init (26*26*1000) ~f:Fn.id in
+  Array.permute ids;
+  ids
+
+let new_robot () =
+  index := !index + 1;
+  {index = unique_ids.(!index)}
+
+let name r =
+  let n = r.index in
+  let letters_part = n / 1000 in
+  let letter_A = Char.to_int 'A' in
+  let first_letter = Char.of_int_exn (letter_A + (letters_part / 26)) in
+  let second_letter = Char.of_int_exn (letter_A + (letters_part % 26)) in
+  sprintf "%c%c%03d" first_letter second_letter (n % 1000)
+
+let reset r =
+  index := !index + 1;
+  r.index <- unique_ids.(!index);

data/tracks/ocaml/exercises/robot-name/robot_name.mli

@@ -0,0 +1,7 @@
+type robot
+
+val new_robot : unit -> robot
+
+val name : robot -> string
+
+val reset : robot -> unit

data/tracks/ocaml/exercises/robot-name/test.ml

@@ -0,0 +1,64 @@
+open Core.Std
+open OUnit2
+open Robot_name
+
+let assert_matches_spec name =
+  let is_valid_letter ch = 'A' <= ch && ch <= 'Z' in
+  let is_valid_digit ch = '0' <= ch && ch <= '9' in
+  assert_equal ~printer:Int.to_string 5 (String.length name);
+  assert_bool ("First character must be from A to Z") (is_valid_letter @@ name.[0]);
+  assert_bool ("Second character must be from A to Z") (is_valid_letter @@ name.[1]);
+  assert_bool ("Third character must be from 0 to 9") (is_valid_digit @@ name.[2]);
+  assert_bool ("Fourth character must be from 0 to 9") (is_valid_digit @@ name.[3]);
+  assert_bool ("Fifth character must be from 0 to 9") (is_valid_digit @@ name.[4]);;
+
+let basic_tests = [
+  "a robot has a name of 2 letters followed by 3 numbers" >:: (fun _ctxt ->
+    let n = name (new_robot ()) in
+    assert_matches_spec n
+    );
+
+  "resetting a robot's name gives it a different name" >:: (fun _ctxt ->
+    let r = new_robot () in
+    let n1 = name r in
+    reset r;
+    let n2 = name r in
+    assert_bool ("'" ^ n1 ^ "' was repeated") (n1 <> n2)
+    );
+
+  "after reset the robot's name still matches the specification" >:: (fun _ctxt ->
+    let r = new_robot () in
+    reset r;
+    let n = name r in
+    assert_matches_spec n
+    );
+]
+
+(*
+Optionally: make this test pass.
+
+There are 26 * 26 * 10 * 10 * 10 = 676,000 possible Robot names.
+This test generates all possible Robot names, and checks that there are
+no duplicates. It's harder to make pass than the other tests, so it is left
+as optional.
+
+To enable it, uncomment the code in the run_test_tt_main
+line at the bottom of this module.
+*)
+let unique_name_tests = [
+  "all possible robot names are distinct" >:: (fun _ctxt ->
+    let rs = Array.init (26 * 26 * 1000) ~f:(fun _ -> new_robot ()) in
+    let (repeated, _) = Array.fold rs ~init:(String.Set.empty, String.Set.empty) ~f:(fun (repeated, seen) r ->
+      let n = name r in
+      if Set.mem seen n
+      then (Set.add repeated n, seen)
+      else (repeated, Set.add seen n)
+      ) in
+    let first_few_repeats = Array.slice (Set.to_array repeated) 0 (min 20 (Set.length repeated)) in
+    let failure_message = "first few repeats: " ^ (String.concat_array first_few_repeats ~sep:",") in
+    assert_bool failure_message (Set.is_empty repeated)
+    );
+]
+
+let () =
+  run_test_tt_main ("robot-name tests" >::: List.concat [basic_tests (* ; unique_name_tests *)])

data/tracks/ocaml/tools/test-generator/Makefile

@@ -1,6 +1,9 @@
 test: test_gen.native
 	@./all_tests.native
 
+canonical_data_checker.native: all_tests.native src/*.ml interfaces/*.mli test/*.ml
+	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is src,interfaces canonical_data_checker.native
+
 test_gen.byte: all_tests.native src/*.ml interfaces/*.mli test/*.ml
 	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is src,interfaces test_gen.byte
 

data/tracks/ocaml/tools/test-generator/README.md

@@ -0,0 +1 @@
+Placeholder

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

@@ -0,0 +1,23 @@
+open Core.Std
+
+let is_directory =
+  Command.Spec.Arg_type.create
+    (fun n ->
+       match Sys.is_directory n with
+       | `Yes -> n
+       | `No | `Unknown ->
+         eprintf "'%s' is not a regular folder.\n%!" n;
+         exit 1
+    )
+
+let command =
+  Command.basic
+    ~summary:"Reports errors in canonical data."
+    Command.Spec.(
+      empty
+      +> flag "-c" (optional_with_default "../../../x-common/exercises" is_directory) ~doc:"string Directory containing canonical data."
+    )
+    (fun canonical_data_folder () -> Controller.check_canonical_data canonical_data_folder)
+
+let () =
+  Command.run ~version:"0.1" command

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

@@ -53,3 +53,15 @@ let run ~(templates_folder: string) ~(canonical_data_folder: string) ~(output_fo
   let canonical_data_files = find_canonical_data_files canonical_data_folder in
   let combined = combine_files template_files canonical_data_files in
   output_tests combined output_folder
+
+let check_canonical_data canonical_data_folder =
+  let ok_count = ref 0 in
+  let canonical_data_files = find_canonical_data_files canonical_data_folder in
+  let canonical_data_files = List.sort canonical_data_files ~cmp:(fun (s1, _) (s2, _) -> String.compare s1 s2) in
+  let total_count = List.length canonical_data_files in
+  List.iter canonical_data_files ~f:(fun (slug, text) ->
+    match parse_json_text text with
+    | Error e -> print_endline @@ slug ^ ": " ^ (show_error e)
+    | _ -> ok_count := !ok_count + 1
+  );
+  print_endline @@ "There are " ^ (Int.to_string total_count) ^ " exercises with canonical data, " ^ (Int.to_string !ok_count) ^ " can be parsed."

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

@@ -5,19 +5,22 @@ open Yojson.Safe.Util
 open Model
 
 type error =
-    TestMustHaveKeyCalledCases | ExpectingListOfCases | ExpectingMapForCase |
-    BadDescription | BadExpected | UnrecognizedJson [@@deriving eq, show]
+    TestMustHaveKeyCalledCases of string | ExpectingListOfCases | ExpectingMapForCase |
+    NoDescription | BadDescription | NoExpected of string | BadExpected | UnrecognizedJson [@@deriving eq, show]
 
-let to_int_unsafe = function
-  | `Int x -> x
-  | _ -> failwith "need an int here"
+let to_int_safe = function
+  | `Int x -> Some x
+  | _ -> None
 
-let to_list_safe xs = match xs with
+let to_list_safe xs = let open Option.Monad_infix in match xs with
   | [] -> Some (StringList [])
   | `String x :: _ -> Some (StringList (List.map xs ~f:to_string))
-  | `Int x :: _ -> Some (IntList (List.map xs ~f:to_int_unsafe))
+  | `Int x :: _ -> List.map xs ~f:to_int_safe |> sequence_option >>= (fun xs -> Some (IntList xs))
   | _ -> None
 
+let q xs = let open Option.Monad_infix in
+  List.map xs ~f:(fun (k,v) -> (to_int_safe v |> Option.map ~f:(fun v -> (k,v))))
+
 let to_parameter (s: json) = match s with
   | `Null -> Some (Null)
   | `String x -> Some (String x)
@@ -25,7 +28,9 @@ let to_parameter (s: json) = match s with
   | `Int x -> Some (Int x)
   | `Bool x -> Some (Bool x)
   | `List x -> to_list_safe  x
-  | `Assoc x -> Some (IntStringMap (List.map x ~f:(fun (k,v) -> (k,to_int_unsafe v))))
+  | `Assoc xs -> let open Option.Monad_infix in
+      let xs = List.map xs ~f:(fun (k,v) -> (to_int_safe v |> Option.map ~f:(fun v -> (k,v)))) in
+      sequence_option xs >>= fun xs -> Some (IntStringMap xs)
   | _ -> None
 
 let parse_parameters (parameters: (string * json) list): parameter elements =
@@ -36,9 +41,9 @@ let parse_case_assoc (parameters: (string * json) list): (case, error) Result.t
   let test_parameters = List.Assoc.remove parameters "description" in
   let test_parameters = List.Assoc.remove test_parameters "expected" in
   let open Result.Monad_infix in
-  find "description" BadDescription >>=
+  find "description" NoDescription >>=
   to_string_note BadDescription >>= fun description ->
-  find "expected" BadExpected >>= fun expectedJson ->
+  find "expected" (NoExpected description) >>= fun expectedJson ->
   to_parameter expectedJson |> Result.of_option ~error:BadExpected >>= fun expected ->
   Ok {description = description; parameters = parse_parameters test_parameters; expected = expected}
 
@@ -48,7 +53,7 @@ let parse_case (s: json): (case, error) Result.t = match s with
 
 let parse_cases (text: string): (json, error) Result.t =
   match from_string text |> member "cases" with
-    | `Null -> Error TestMustHaveKeyCalledCases
+    | `Null -> Error (TestMustHaveKeyCalledCases "xx")
     | json -> Ok json
 
 let parse_single (text: string): (tests, error) Result.t =
@@ -59,17 +64,18 @@ let parse_single (text: string): (tests, error) Result.t =
   Result.return (Single ts)
 
 let is_suite (json: json) =
-  let keys = List.sort (keys json) ~cmp:String.compare in
+  let keys = List.filter (keys json) ~f:(fun k -> k <> "methods") in
+  let keys = List.sort keys ~cmp:String.compare in
   not (List.is_empty keys || keys = ["cases"] || keys = ["#"; "cases"])
 
 let merge_result = function
   | (_, Error x) -> Error x
   | (n, Ok c) -> Ok {name = n; cases = c}
 
-let parse_cases_from_suite suite =
+let parse_cases_from_suite name suite =
   let open Result.Monad_infix in
-  member_note UnrecognizedJson "cases" suite >>=
-  to_list_note UnrecognizedJson >>= fun tests ->
+  member_note (TestMustHaveKeyCalledCases name) "cases" suite >>=
+  to_list_note ExpectingListOfCases >>= fun tests ->
   List.map tests ~f:parse_case |> sequence
 
 let parse_json_text (text: string): (tests, error) Result.t =
@@ -78,18 +84,19 @@ let parse_json_text (text: string): (tests, error) Result.t =
   if is_suite json
   then
     to_assoc_note UnrecognizedJson json >>= fun tests ->
-    Result.return (List.map tests ~f:(fun (name, suite) -> merge_result (name, parse_cases_from_suite suite))) >>= fun tests ->
+    let tests = List.filter tests ~f:(fun (n, _) -> n <> "#") in
+    let tests = List.map tests ~f:(fun (name, suite) -> merge_result (name, parse_cases_from_suite name suite)) in
     sequence tests >>= fun tests ->
     Ok (Suite tests)
   else
     parse_single text
 
 let show_error = function
-  | TestMustHaveKeyCalledCases -> "Cannot parse this json - " ^
-      "expecting an object with a key: 'cases'"
+  | TestMustHaveKeyCalledCases name -> "Test named '" ^ name ^ "' is expected to have an object with a key: 'cases'"
   | ExpectingMapForCase -> "Expected a json map for a test case"
-  | ExpectingListOfCases -> "Expected a top level map with key cases, " ^
-      "and a list of cases as its value."
-  | BadDescription -> "Case is missing a description or it is not a string."
-  | BadExpected -> "Case is missing an expected key or it is not a string."
+  | ExpectingListOfCases -> "Expected a top level map with key cases, and a list of cases as its value."
+  | NoDescription -> "Case is missing a description."
+  | BadDescription -> "Description is not a string."
+  | NoExpected s -> "Case '" ^ s ^ "' is missing an expected key."
+  | BadExpected -> "Do not understand type of Expected key."
   | UnrecognizedJson -> "Cannot understand this json."

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

@@ -7,9 +7,17 @@ let map2 (f: 'a -> 'b -> 'c) (r1: ('a, 'e) Result.t) (r2: ('b, 'e) Result.t): ('
   | (_, Error x) -> Error x
   | (Ok a, Ok b) -> Ok (f a b)
 
+let map2_option (f: 'a -> 'b -> 'c) (r1: 'a option) (r2: 'b option): 'c option = match (r1, r2) with
+  | (None, _) -> None
+  | (_, None) -> None
+  | (Some a, Some b) -> Some (f a b)
+
 let sequence (rs: (('a, 'e) Result.t) list): (('a list), 'e) Result.t =
   List.fold_right rs ~init:(Ok []) ~f:(map2 (fun x xs -> x :: xs))
 
+let sequence_option (rs: ('a option) list): ('a list) option =
+  List.fold_right rs ~init:(Some []) ~f:(map2_option (fun x xs -> x :: xs))
+
 let to_list_option json =
   try Some (to_list json) with Type_error _ -> None
 

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

@@ -0,0 +1,437 @@
+
+{
+   "#": [
+      "Most languages require constructing a clock with initial values,",
+      "adding a positive or negative number of minutes, and testing equality",
+      "in some language-native way.  Some languages require separate add and",
+      "subtract functions.  Negative and out of range values are generally",
+      "expected to wrap around rather than represent errors."
+   ],
+   "create": {
+      "description": [
+         "Test creating a new clock with an initial time."
+      ],
+      "cases": [
+         {
+            "description": "on the hour",
+            "hour": 8,
+            "minute": 0,
+            "expected": "08:00"
+         },
+         {
+            "description": "past the hour",
+            "hour": 11,
+            "minute": 9,
+            "expected": "11:09"
+         },
+         {
+            "description": "midnight is zero hours",
+            "hour": 24,
+            "minute": 0,
+            "expected": "00:00"
+         },
+         {
+            "description": "hour rolls over",
+            "hour": 25,
+            "minute": 0,
+            "expected": "01:00"
+         },
+         {
+            "description": "hour rolls over continuously",
+            "hour": 100,
+            "minute": 0,
+            "expected": "04:00"
+         },
+         {
+            "description": "sixty minutes is next hour",
+            "hour": 1,
+            "minute": 60,
+            "expected": "02:00"
+         },
+         {
+            "description": "minutes roll over",
+            "hour": 0,
+            "minute": 160,
+            "expected": "02:40"
+         },
+         {
+            "description": "minutes roll over continuously",
+            "hour": 0,
+            "minute": 1723,
+            "expected": "04:43"
+         },
+         {
+            "description": "hour and minutes roll over",
+            "hour": 25,
+            "minute": 160,
+            "expected": "03:40"
+         },
+         {
+            "description": "hour and minutes roll over continuously",
+            "hour": 201,
+            "minute": 3001,
+            "expected": "11:01"
+         },
+         {
+            "description": "hour and minutes roll over to exactly midnight",
+            "hour": 72,
+            "minute": 8640,
+            "expected": "00:00"
+         },
+         {
+            "description": "negative hour",
+            "hour": -1,
+            "minute": 15,
+            "expected": "23:15"
+         },
+         {
+            "description": "negative hour rolls over",
+            "hour": -25,
+            "minute": 0,
+            "expected": "23:00"
+         },
+         {
+            "description": "negative hour rolls over continuously",
+            "hour": -91,
+            "minute": 0,
+            "expected": "05:00"
+         },
+         {
+            "description": "negative minutes",
+            "hour": 1,
+            "minute": -40,
+            "expected": "00:20"
+         },
+         {
+            "description": "negative minutes roll over",
+            "hour": 1,
+            "minute": -160,
+            "expected": "22:20"
+         },
+         {
+            "description": "negative minutes roll over continuously",
+            "hour": 1,
+            "minute": -4820,
+            "expected": "16:40"
+         },
+         {
+            "description": "negative hour and minutes both roll over",
+            "hour": -25,
+            "minute": -160,
+            "expected": "20:20"
+         },
+         {
+            "description": "negative hour and minutes both roll over continuously",
+            "hour": -121,
+            "minute": -5810,
+            "expected": "22:10"
+         }
+      ]
+   },
+   "add": {
+      "description": [
+         "Test adding and subtracting minutes."
+      ],
+      "cases": [
+         {
+            "description": "add minutes",
+            "hour": 10,
+            "minute": 0,
+            "add": 3,
+            "expected": "10:03"
+         },
+         {
+            "description": "add no minutes",
+            "hour": 6,
+            "minute": 41,
+            "add": 0,
+            "expected": "06:41"
+         },
+         {
+            "description": "add to next hour",
+            "hour": 0,
+            "minute": 45,
+            "add": 40,
+            "expected": "01:25"
+         },
+         {
+            "description": "add more than one hour",
+            "hour": 10,
+            "minute": 0,
+            "add": 61,
+            "expected": "11:01"
+         },
+         {
+            "description": "add more than two hours with carry",
+            "hour": 0,
+            "minute": 45,
+            "add": 160,
+            "expected": "03:25"
+         },
+         {
+            "description": "add across midnight",
+            "hour": 23,
+            "minute": 59,
+            "add": 2,
+            "expected": "00:01"
+         },
+         {
+            "description": "add more than one day (1500 min = 25 hrs)",
+            "hour": 5,
+            "minute": 32,
+            "add": 1500,
+            "expected": "06:32"
+         },
+         {
+            "description": "add more than two days",
+            "hour": 1,
+            "minute": 1,
+            "add": 3500,
+            "expected": "11:21"
+         },
+         {
+            "description": "subtract minutes",
+            "hour": 10,
+            "minute": 3,
+            "add": -3,
+            "expected": "10:00"
+         },
+         {
+            "description": "subtract to previous hour",
+            "hour": 10,
+            "minute": 3,
+            "add": -30,
+            "expected": "09:33"
+         },
+         {
+            "description": "subtract more than an hour",
+            "hour": 10,
+            "minute": 3,
+            "add": -70,
+            "expected": "08:53"
+         },
+         {
+            "description": "subtract across midnight",
+            "hour": 0,
+            "minute": 3,
+            "add": -4,
+            "expected": "23:59"
+         },
+         {
+            "description": "subtract more than two hours",
+            "hour": 0,
+            "minute": 0,
+            "add": -160,
+            "expected": "21:20"
+         },
+         {
+            "description": "subtract more than two hours with borrow",
+            "hour": 6,
+            "minute": 15,
+            "add": -160,
+            "expected": "03:35"
+         },
+         {
+            "description": "subtract more than one day (1500 min = 25 hrs)",
+            "hour": 5,
+            "minute": 32,
+            "add": -1500,
+            "expected": "04:32"
+         },
+         {
+            "description": "subtract more than two days",
+            "hour": 2,
+            "minute": 20,
+            "add": -3000,
+            "expected": "00:20"
+         }
+      ]
+   },
+   "equal": {
+      "description": [
+         "Construct two separate clocks, set times, test if they are equal."
+      ],
+      "cases": [
+         {
+            "description": "clocks with same time",
+            "clock1": {
+               "hour": 15,
+               "minute": 37
+            },
+            "clock2": {
+               "hour": 15,
+               "minute": 37
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks a minute apart",
+            "clock1": {
+               "hour": 15,
+               "minute": 36
+            },
+            "clock2": {
+               "hour": 15,
+               "minute": 37
+            },
+            "expected": false
+         },
+         {
+            "description": "clocks an hour apart",
+            "clock1": {
+               "hour": 14,
+               "minute": 37
+            },
+            "clock2": {
+               "hour": 15,
+               "minute": 37
+            },
+            "expected": false
+         },
+         {
+            "description": "clocks with hour overflow",
+            "clock1": {
+               "hour": 10,
+               "minute": 37
+            },
+            "clock2": {
+               "hour": 34,
+               "minute": 37
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with hour overflow by several days",
+            "clock1": {
+               "hour": 3,
+               "minute": 11
+            },
+            "clock2": {
+               "hour": 99,
+               "minute": 11
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative hour",
+            "clock1": {
+               "hour": 22,
+               "minute": 40
+            },
+            "clock2": {
+               "hour": -2,
+               "minute": 40
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative hour that wraps",
+            "clock1": {
+               "hour": 17,
+               "minute": 3
+            },
+            "clock2": {
+               "hour": -31,
+               "minute": 3
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative hour that wraps multiple times",
+            "clock1": {
+               "hour": 13,
+               "minute": 49
+            },
+            "clock2": {
+               "hour": -83,
+               "minute": 49
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with minute overflow",
+            "clock1": {
+               "hour": 0,
+               "minute": 1
+            },
+            "clock2": {
+               "hour": 0,
+               "minute": 1441
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with minute overflow by several days",
+            "clock1": {
+               "hour": 2,
+               "minute": 2
+            },
+            "clock2": {
+               "hour": 2,
+               "minute": 4322
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative minute",
+            "clock1": {
+               "hour": 2,
+               "minute": 40
+            },
+            "clock2": {
+               "hour": 3,
+               "minute": -20
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative minute that wraps",
+            "clock1": {
+               "hour": 4,
+               "minute": 10
+            },
+            "clock2": {
+               "hour": 5,
+               "minute": -1490
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative minute that wraps multiple times",
+            "clock1": {
+               "hour": 6,
+               "minute": 15
+            },
+            "clock2": {
+               "hour": 6,
+               "minute": -4305
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative hours and minutes",
+            "clock1": {
+               "hour": 7,
+               "minute": 32
+            },
+            "clock2": {
+               "hour": -12,
+               "minute": -268
+            },
+            "expected": true
+         },
+         {
+            "description": "clocks with negative hours and minutes that wrap",
+            "clock1": {
+               "hour": 18,
+               "minute": 7
+            },
+            "clock2": {
+               "hour": -54,
+               "minute": -11513
+            },
+            "expected": true
+         }
+      ]
+   }
+}