trackler 2.0.6.30 → 2.0.6.31

data/tracks/ocaml/SETUP.md

@@ -9,19 +9,7 @@ To work on the exercises, you will need `Opam` and `Core`. Consult [opam](https:
 opam install core
 
 ## Running Tests
-Because OCaml is a compiled language you need to compile your submission and the test code before you can run the tests. Compile with
-
-```bash
-$ corebuild -quiet test.native
-```
-
-and when successful run the tests by running the `test.native` executable:
-
-```bash
-./test.native
-```
-
-Alternatively just type
+A Makefile is provided with a default target to compile your solution and run the tests. At the command line, type:
 
 ```bash
 make

data/tracks/ocaml/exercises/atbash-cipher/test.ml

@@ -4,34 +4,43 @@ open Atbash_cipher
 
 let ae exp got _test_ctxt = assert_equal ~printer:String.to_string exp got
 
-let tests =
-  ["encode yes">::
-   ae "bvh" (encode "yes");
-   "encode no">::
-   ae "ml" (encode "no");
-   "encode OMG">::
-   ae "lnt" (encode "OMG");
-   "encode spaces">::
-   ae "lnt" (encode "O M G");
-   "encode mindblowingly">::
-   ae "nrmwy oldrm tob" (encode "mindblowingly");
-   "encode numbers">::
-   ae "gvhgr mt123 gvhgr mt" (encode "Testing,1 2 3, testing.");
-   "encode deep thought">::
-   ae "gifgs rhurx grlm" (encode "Truth is fiction.");
-   "encode all the letters">::
-   ae "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt" (encode "The quick brown fox jumps over the lazy dog.");
-   "encode ignores non ascii">::
-   ae "mlmzh xrrrt mlivw" (encode "non ascii éignored");
-   "encode mindblowingly with a different block size">::
-   ae "n r m w y o l d r m t o b" (encode ~block_size:1 "mindblowingly");
-   "decode exercism">::
-   ae "exercism" (decode "vcvix rhn");
-   "decode a sentence">::
-   ae "anobstacleisoftenasteppingstone" (decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v");
-   "decode all the letters">::
-   ae "thequickbrownfoxjumpsoverthelazydog" (decode "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt");
-  ]
+let encode_tests = [
+   "encode yes" >::
+     ae "bvh" (encode "yes");
+   "encode no" >::
+     ae "ml" (encode "no");
+   "encode OMG" >::
+     ae "lnt" (encode "OMG");
+   "encode spaces" >::
+     ae "lnt" (encode "O M G");
+   "encode mindblowingly" >::
+     ae "nrmwy oldrm tob" (encode "mindblowingly");
+   "encode numbers" >::
+     ae "gvhgr mt123 gvhgr mt" (encode "Testing,1 2 3, testing.");
+   "encode deep thought" >::
+     ae "gifgs rhurx grlm" (encode "Truth is fiction.");
+   "encode all the letters" >::
+     ae "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt" (encode "The quick brown fox jumps over the lazy dog.");
+]
+
+let decode_tests = [
+   "decode exercism" >::
+     ae "exercism" (decode "vcvix rhn");
+   "decode a sentence" >::
+     ae "anobstacleisoftenasteppingstone" (decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v");
+   "decode numbers" >::
+     ae "testing123testing" (decode "gvhgr mt123 gvhgr mt");
+   "decode all the letters" >::
+     ae "thequickbrownfoxjumpsoverthelazydog" (decode "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt");
+]
+
+let different_block_size_test = [
+  "encode mindblowingly with a different block size">::
+    ae "n r m w y o l d r m t o b" (encode ~block_size:1 "mindblowingly");
+]
 
 let () =
-  run_test_tt_main ("atbash cipher" >::: tests)
+  run_test_tt_main (
+    "atbash-cipher tests" >:::
+      List.concat [encode_tests; decode_tests; different_block_size_test]
+  )

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

@@ -1,10 +1,11 @@
 open Core.Std
 
 open Model
+open Yojson.Basic
 
-type edit_expected_function = value: parameter -> string
+type edit_expected_function = value: json -> string
 
-type edit_parameters_function = (string * string) list -> (string * string) list
+type edit_parameters_function = (string * json) list -> (string * string) list
 
 type subst = Subst of string [@@deriving eq, show]
 
@@ -22,7 +23,7 @@ let rec replace_keys (f: edit_expected_function) (ed: edit_parameters_function)
   let expected = f ~value:c.expected in
   let s = replace_key "expected" expected s in
   let s = replace_key "suite-name" suite_name s in
-  let parameter_strings = ed @@ List.map ~f:(fun (k,p) -> (k,parameter_to_string p)) c.parameters in
+  let parameter_strings = ed @@ List.map ~f:(fun (k,p) -> (k,p)) c.parameters in
   List.fold parameter_strings ~init:(Subst s) ~f:(fun (Subst s) (k,v) -> Subst (replace_key k v s))
 
 let fill_in_template (f: edit_expected_function) (ed: edit_parameters_function) test_template suite_name cases =

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

@@ -24,7 +24,7 @@ let combine_files (template_files: (string * content) list) (canonical_data_file
 
 let generate_code ~(slug: string) ~(template_file: content) ~(canonical_data_file: content): (content, content) Result.t =
   let template = find_template template_file in
-  let edit_expected = edit_expected ~stringify:parameter_to_string ~slug in
+  let edit_expected = edit_expected ~stringify:json_to_string ~slug in
   let edit_parameters = edit_parameters ~slug in
   let fill_in_template = fill_in_template edit_expected edit_parameters in
   let open Result.Monad_infix in

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

@@ -1,43 +1,26 @@
 open Core.Std
 
 open Utils
-
-type parameter =
-  | Null
-  | String of string
-  | Float of float
-  | Int of int
-  | Bool of bool
-  | StringList of (string list)
-  | IntList of (int list)
-  | IntTupleList of ((int * int) list)
-  | IntStringMap of ((string * int) list) [@@deriving eq, show]
-
-type 'a elements = (string * 'a) list [@@deriving eq, show]
+open Yojson.Basic
 
 type case = {
   description: string;
-  parameters: parameter elements;
-  expected: parameter;
-} [@@deriving eq, show]
+  parameters: (string * json) list;
+  expected: json;
+}
 
-type test = {name: string; cases: case list} [@@deriving eq, show]
+type test = {name: string; cases: case list}
 
 type tests =
   | Single of case list
-  | Suite of test list [@@deriving eq, show]
-
-let surround (ch: char) (s: string): string =
-  Char.to_string ch ^ s ^ Char.to_string ch
-
-let parameter_to_string = function
-  | Null -> "null"
-  | String s -> String.escaped s
-  | Float f -> Float.to_string f
-  | Int n -> Int.to_string n
-  | Bool b -> Bool.to_string b
-  | StringList xs -> "[" ^ String.concat ~sep:"; " (List.map ~f:(surround '\"' >> String.escaped) xs) ^ "]"
-  | IntList xs -> "[" ^ String.concat ~sep:"; " (List.map ~f:Int.to_string xs) ^ "]"
-  | IntTupleList xs -> "[" ^ String.concat ~sep:"; " (List.map xs ~f:(fun (x,y) -> sprintf "(%d,%d)" x y)) ^ "]"
-  | IntStringMap xs -> "[" ^ String.concat ~sep:"; "
-                         (List.map xs ~f:(fun (k,v) -> "(\"" ^ String.escaped k ^ "\", " ^ Int.to_string v ^ ")")) ^ "]"
+  | Suite of test list
+
+let rec json_to_string (j: json): string = match j with
+  | `Null -> "null"
+  | `String s -> "\"" ^ (String.escaped s) ^ "\""
+  | `Float f -> Float.to_string f
+  | `Int n -> Int.to_string n
+  | `Bool b -> Bool.to_string b
+  | `List xs -> "[" ^ String.concat ~sep:"; " (List.map ~f:json_to_string xs) ^ "]"
+  | `Assoc xs -> "[" ^ String.concat ~sep:"; "
+                         (List.map xs ~f:(fun (k,v) -> "(\"" ^ String.escaped k ^ "\", " ^ json_to_string v ^ ")")) ^ "]"

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

@@ -8,38 +8,6 @@ type error =
     TestMustHaveKeyCalledCases of string | ExpectingListOfCases | ExpectingMapForCase |
     NoDescription | BadDescription | NoExpected of string | BadExpected | UnrecognizedJson [@@deriving eq, show]
 
-let to_int_safe = function
-| `Int x -> Some x
-| _ -> None
-
-let to_tuple_safe xs = match xs with
-| `List [`Int x; `Int y] -> Some (x,y)
-| _ -> None
-
-let rec to_list_safe xs: parameter option = let open Option.Monad_infix in match xs with
-| [] -> Some (StringList [])
-| `String x :: _ -> Some (StringList (List.map xs ~f:to_string))
-| `Int x :: _ -> List.map xs ~f:to_int_safe |> sequence_option >>= (fun xs -> Some (IntList xs))
-| `List x :: _ -> List.map xs ~f:to_tuple_safe |> sequence_option >>= (fun xs -> Some (IntTupleList 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)
-| `Float x -> Some (Float x)
-| `Int x -> Some (Int x)
-| `Bool x -> Some (Bool x)
-| `List x -> to_list_safe x
-| `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)
-
-let parse_parameters (parameters: (string * json) list): parameter elements =
-  List.filter_map parameters ~f:(fun (k, v) -> Option.map ~f:(fun v -> (k, v)) (to_parameter v))
-
 let parse_case_assoc (parameters: (string * json) list) (expected_key: string): (case, error) Result.t =
   let find name e = List.Assoc.find parameters name |> Result.of_option ~error:e in
   let test_parameters = List.Assoc.remove parameters "description" in
@@ -47,9 +15,8 @@ let parse_case_assoc (parameters: (string * json) list) (expected_key: string):
   let open Result.Monad_infix in
   find "description" NoDescription >>=
   to_string_note BadDescription >>= fun description ->
-  find expected_key (NoExpected description) >>= fun expectedJson ->
-  to_parameter expectedJson |> Result.of_option ~error:BadExpected >>= fun expected ->
-  Ok {description = description; parameters = parse_parameters test_parameters; expected = expected}
+  find expected_key (NoExpected description) >>= fun expected ->
+  Ok {description = description; parameters = test_parameters; expected = expected}
 
 let parse_case (expected_key: string) (s: json): (case, error) Result.t = match s with
   | `Assoc assoc -> parse_case_assoc assoc expected_key

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

@@ -1,60 +1,73 @@
 open Core.Std
 
 open Model
+open Yojson.Basic
+
+let map_elements (to_str: json -> string) (parameters: (string * json) list): (string * string) list =
+  List.map parameters ~f:(fun (k,j) -> (k,to_str j))
 
 let optional_int ~(none: int) = function
-| Int n when n = none -> "None"
-| Int n -> "(Some " ^ Int.to_string n ^ ")"
-| x -> parameter_to_string x
+| `Int n when n = none -> "None"
+| `Int n -> "(Some " ^ Int.to_string n ^ ")"
+| x -> json_to_string x
 
 let optional_int_list = function
-| IntList xs -> "(Some [" ^ String.concat ~sep:"; " (List.map ~f:Int.to_string xs) ^ "])"
+| `List xs -> "(Some [" ^ String.concat ~sep:"; " (List.map ~f:json_to_string xs) ^ "])"
 | _ -> "None"
 
 let optional_int_or_string ~(none: int) = function
-| String s -> "(Some \"" ^ s ^ "\")"
-| Int n when n = none -> "None"
-| x -> parameter_to_string x
+| `String s -> "(Some \"" ^ s ^ "\")"
+| `Int n when n = none -> "None"
+| x -> json_to_string x
 
 let default_value ~(key: string) ~(value: string) (parameters: (string * string) list): (string * string) list =
   if List.exists ~f:(fun (k, _) -> k = key) parameters
   then parameters
   else (key, value) :: parameters
 
-let optional_strings ~(f: string -> bool) (parameters: (string * string) list): (string * string) list =
+let optional_strings ~(f: string -> bool) (parameters: (string * json) list): (string * string) list =
   let replace parameter =
     let (k, v) = parameter in
     if f k
-    then (k, "(Some \"" ^ v ^ "\")")
-    else parameter in
+    then (k, "(Some " ^ json_to_string v ^ ")")
+    else (k, json_to_string v) in
   List.map ~f:replace parameters
 
-let edit_expected ~(stringify: parameter -> string) ~(slug: string) ~(value: parameter) = match slug with
+let edit_expected ~(stringify: json -> string) ~(slug: string) ~(value: json) = match slug with
 | "hamming" -> optional_int ~none:(-1) value
 | "all-your-base" -> optional_int_list value
 | "say" -> optional_int_or_string ~none:(-1) value
 | _ -> stringify value
 
-let edit_say (ps: (string * string) list) =
+let edit_say (ps: (string * json) list) =
   let edit = function
-  | ("input", v) -> ("input", if Int.of_string v >= 0 then "(" ^ v ^ "L)" else v ^ "L")
-  | x -> x in
+  | ("input", v) -> ("input", let v = json_to_string v in if Int.of_string v >= 0 then "(" ^ v ^ "L)" else v ^ "L")
+  | (k, ps) -> (k, json_to_string ps) in
   List.map ps ~f:edit
 
-let edit_all_your_base (ps: (string * string) list) =
+let edit_all_your_base (ps: (string * json) list): (string * string) list =
   let edit = function
-  | ("output_base", v) -> ("output_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
-  | ("input_base", v) -> ("input_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
-  | x -> x in
+  | ("output_base", v) -> let v = json_to_string v in ("output_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
+  | ("input_base", v) -> let v = json_to_string v in ("input_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
+  | (k, v) -> (k, json_to_string v) in
   List.map ps ~f:edit
 
-let edit_parameters ~(slug: string) (parameters: (string * string) list) = match (slug, parameters) with
-| ("hello-world", ps) -> default_value ~key:"name" ~value:"None"
-  @@ optional_strings ~f:(fun _x -> true)
-  @@ parameters
+let two_elt_list_to_tuple (j: json): string = match j with
+| `List [`Int x1; `Int x2] -> sprintf "(%d,%d)" x1 x2
+| _ -> failwith "two element list expected, but got " ^ (json_to_string j)
+ 
+let edit_dominoes (ps: (string * json) list): (string * string) list =
+  let edit (p: (string * json)) = match p with
+  | ("input", `List j) -> ("input", "[" ^ (List.map ~f:two_elt_list_to_tuple j |> String.concat ~sep:"; ") ^ "]")
+  | (k, v) -> (k, json_to_string v) in
+  List.map ps ~f:edit
+  
+let edit_parameters ~(slug: string) (parameters: (string * json) list) = match (slug, parameters) with
+| ("hello-world", ps) -> default_value ~key:"name" ~value:"None" (optional_strings ~f:(fun _x -> true) parameters)
 | ("say", ps) -> edit_say ps
 | ("all-your-base", ps) -> edit_all_your_base ps
-| (_, ps) -> ps
+| ("dominoes", ps) -> edit_dominoes ps
+| (_, ps) -> map_elements json_to_string ps
 
 let expected_key_name slug = match slug with
 | "dominoes" -> "can_chain"

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

@@ -9,7 +9,7 @@ let ae exp got _test_ctxt =
 let tests = [
 (* TEST
   "$description" >::
-    ae $expected (anagrams "$subject" $candidates);
+    ae $expected (anagrams $subject $candidates);
    END TEST *)
 ]
 

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

@@ -0,0 +1,24 @@
+open Core.Std
+open OUnit2
+open Atbash_cipher
+
+let ae exp got _test_ctxt = assert_equal ~printer:String.to_string exp got
+
+let (* SUITE *)$(suite_name)_tests = [
+(* TEST
+   "$description" >::
+     ae $expected ($suite-name $phrase);
+   END TEST *)
+]
+(* END SUITE *)
+
+let different_block_size_test = [
+  "encode mindblowingly with a different block size" >::
+    ae "n r m w y o l d r m t o b" (encode ~block_size:1 "mindblowingly");
+]
+
+let () =
+  run_test_tt_main (
+    "atbash-cipher tests" >:::
+      List.concat [(* suite-all-names *); different_block_size_test]
+  )

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

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

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

@@ -8,7 +8,7 @@ let ae exp got _test_ctxt =
 let tests = [
 (* TEST
   "$description" >::
-    ae $expected (are_balanced "$input");
+    ae $expected (are_balanced $input);
 END TEST *)
 ]
 

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

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

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

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

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

@@ -8,7 +8,7 @@ let assert_valid expected input _test_ctxt =
 let tests = [
 (* TEST
   "$description" >::
-    assert_valid $expected "$input";
+    assert_valid $expected $input;
 END TEST *)
 ]
 

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

@@ -7,7 +7,7 @@ let ae exp got _test_ctxt = assert_equal ~printer:Bool.to_string exp got
 let tests = [
 (* TEST
    "$description" >::
-      ae $expected (is_pangram "$input");
+      ae $expected (is_pangram $input);
    END TEST *)
 ]
 

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

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

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

@@ -12,7 +12,7 @@ let tests = [
 (* TEST
    "$description" >::
       ae $expected
-         (word_count "$input");
+         (word_count $input);
    END TEST *)
 ]
 

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

@@ -2,11 +2,13 @@ open Core.Std
 open OUnit2
 open Codegen
 open Model
+open Yojson.Basic
 
 let leap_template = "\"$description\" >:: ae $expected (leap_year $input);"
 
-let edit_expected ~value = parameter_to_string value
-let edit_parameters = Fn.id
+let edit_expected ~value = json_to_string value
+let edit_parameters (j: (string * json) list): (string * string) list = 
+    List.map ~f:(fun (k,v) -> (k,to_string v)) j
 let assert_fill_in_template exp cases = assert_equal exp
     ~printer:(fun xs -> "[" ^ (String.concat ~sep:";" xs) ^ "]")
     (fill_in_template edit_expected edit_parameters leap_template "suite-name" cases |> List.map ~f:subst_to_string)
@@ -17,7 +19,7 @@ let codegen_tests = [
   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
+      let c = {description = "leap_year"; parameters = [("input", `Int 1996)]; expected = `Bool true} in
       assert_fill_in_template ["\"leap_year\" >:: ae true (leap_year 1996);"] [c]
     );
 ]

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

@@ -6,24 +6,6 @@ open Model
 let ae exp got _ctxt = assert_equal ~printer:Fn.id exp got
 
 let model_tests = [
-  "int parameter to string" >::
-    ae "8" @@ parameter_to_string (Int 8);
-  "bool parameter to string" >::
-    ae "true" @@ parameter_to_string (Bool true);
-  "string parameter to string" >::
-    ae "xyz" @@ parameter_to_string (String "xyz");
-  "string parameter containing escaped characters to string" >::
-    ae "x\\t\\ny" @@ parameter_to_string (String "x\t\ny");
-  "float parameter to string" >::
-    ae "3.14" @@ parameter_to_string (Float 3.14);
-  "string list parameter to string" >::
-    ae "[\"a\"; \"bc\"; \"def\"]"  @@ parameter_to_string (StringList ["a"; "bc"; "def"]);
-  "string list parameter with escaped characters to string" >::
-    ae "[\"a\\r\"; \"b\\nc\"; \"d\\tef\"]"  @@ parameter_to_string (StringList ["a\r"; "b\nc"; "d\tef"]);
-  "int list parameter to string" >::
-    ae "[1; 2; 3; 4]"  @@ parameter_to_string (IntList [1; 2; 3; 4]);
-  "int string map parameter to string" >::
-    ae "[(\"one\", 1); (\"two\", 1)]"  @@ parameter_to_string (IntStringMap [("one", 1); ("two", 1)]);
-  "int string map parameter to string with escaped characters in the keys" >::
-    ae "[(\"\\t\\r\", 1); (\"two\\n\", 1)]"  @@ parameter_to_string (IntStringMap [("\t\r", 1); ("two\n", 1)]);
+  "json_to_string on list of strings" >::
+    ae "[\"a\"; \"b\"; \"c\"]" @@ json_to_string (`List [`String "a"; `String "b"; `String "c"]);
 ]

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

@@ -3,12 +3,7 @@ open OUnit2
 open Parser
 open Model
 
-let show_cases = function
-  | 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 ae exp got _test_ctxt = assert_equal exp got
 
 let single x = Ok (Single x)
 
@@ -31,41 +26,37 @@ let parser_tests = [
        (call_parser "{\"cases\" : [\"key\"]}");
 
   "parses a single element with a description and expected string output" >::
-    ae (single [{description = "d1"; parameters = []; expected = String "value"}])
+    ae (single [{description = "d1"; parameters = []; expected = `String "value"}])
        (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : \"value\"}]}");
 
   "parses a single element with a description and expected float output" >::
-    ae (single [{description = "d1"; parameters = []; expected = Float 100.}])
+    ae (single [{description = "d1"; parameters = []; expected = `Float 100.}])
        (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : 100.0}]}");
 
   "parses a single element with a description and expected bool output" >::
-    ae (single [{description = "d1"; parameters = []; expected = Bool true}])
+    ae (single [{description = "d1"; parameters = []; expected = `Bool true}])
       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : true}]}");
 
   "parses a single element with a description and expected int list output" >::
-    ae (single [{description = "d1"; parameters = []; expected = IntList [1;2;3]}])
+    ae (single [{description = "d1"; parameters = []; expected = `List [`Int 1;`Int 2;`Int 3]}])
       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : [1, 2, 3]}]}");
 
   "parses a single element with a description and expected null output" >::
-    ae (single [{description = "d1"; parameters = []; expected = Null}])
+    ae (single [{description = "d1"; parameters = []; expected = `Null}])
       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : null}]}");
 
   "parses a single element with an int key value pair" >::
-    ae (single [{description = "d1"; parameters = [("input", Int 1996)]; expected = Bool true}])
+    ae (single [{description = "d1"; parameters = [("input", `Int 1996)]; expected = `Bool true}])
       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : 1996, \"expected\" : true}]}");
 
   "parses a single element with a string key value pair" >::
-    ae (single [{description = "d1"; parameters = [("input", String "some-string")]; expected = Int 85}])
+    ae (single [{description = "d1"; parameters = [("input", `String "some-string")]; expected = `Int 85}])
       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : \"some-string\", \"expected\" : 85}]}");
 
   "parses a single element with a string list key value pair" >::
-    ae (single [{description = "d1"; parameters = [("input", StringList ["s1"; "s2"])]; expected = Int 85}])
+    ae (single [{description = "d1"; parameters = [("input", `List [`String "s1"; `String "s2"])]; expected = `Int 85}])
       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : [\"s1\", \"s2\"], \"expected\" : 85}]}");
 
-  "parses a single element with a int tuple list (modelled as an int list) key value pair" >::
-    ae (single [{description = "d1"; parameters = [("input", IntTupleList [(1,2);(3,4)])]; expected = Int 85}])
-      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : [[1,2],[3,4]], \"expected\" : 85}]}");
-
   "an element without a description is an Error" >::
     ae (Error NoDescription)
       (call_parser "{\"cases\" : [{\"input\" : 11, \"expected\" : 85}]}");
@@ -79,7 +70,7 @@ let parser_tests = [
       (call_parser "{\"cases\" : [{\"input\" : 11}]}");
 
   "parses a map in the expected parameter" >::(fun _ctx ->
-      assert_equal (single [{description = "d1"; parameters = []; expected = IntStringMap [("one", 1); ("two", 2)]}])
+      assert_equal (single [{description = "d1"; parameters = []; expected = `Assoc [("one", `Int 1); ("two", `Int 2)]}])
         (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : {\"one\": 1, \"two\": 2}}]}");
       );
 

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

@@ -3,6 +3,7 @@ open OUnit2
 open Model
 open Codegen
 open Special_cases
+open Yojson.Basic
 
 let ae exp got _ctxt = assert_equal ~printer:Fn.id exp got
 
@@ -10,20 +11,20 @@ let tuples_printer kvs =
   String.concat ~sep:";" @@ List.map ~f:(fun (k,v) -> "(" ^ k ^ "," ^ v ^ ")") kvs
 
 let stringify = function
-  | Bool true -> "stringified"
+  | `Bool true -> "stringified"
   | _ -> failwith "Bad type for stringify"
 
 let special_cases_tests = [
   "for a non special cased slug convert the parameter to a string" >:: (fun _ctx ->
-      assert_equal ~printer:Fn.id "stringified" @@ edit_expected ~stringify ~slug:"some-slug" ~value:(Bool true)
+      assert_equal ~printer:Fn.id "stringified" @@ edit_expected ~stringify ~slug:"some-slug" ~value:(`Bool true)
     );
 
   "an optional int parameter is converted to none if it matches the special value" >:: (fun _ctx ->
-      assert_equal "None" @@ optional_int ~none:88 (Int 88)
+      assert_equal "None" @@ optional_int ~none:88 (`Int 88)
     );
 
   "an optional int parameter is converted to (Some value) if it does not match the special value" >:: (fun _ctx ->
-      assert_equal "(Some 0)" @@ optional_int ~none:88 (Int 0)
+      assert_equal "(Some 0)" @@ optional_int ~none:88 (`Int 0)
     );
 
   "default_value does not provide a default for a list that has the given key already" >:: (fun _ctx ->
@@ -36,7 +37,7 @@ let special_cases_tests = [
     );
 
   "optional_strings replace value with Some(value)" >:: (fun _ctx ->
-      assert_equal ~printer:tuples_printer [("key", "(Some \"value\")"); ("key2", "value2")]
-        @@ optional_strings ~f:(fun x -> x = "key") [("key", "value"); ("key2", "value2")]
+      assert_equal ~printer:tuples_printer [("key", "(Some \"value\")"); ("key2", "\"value2\"")]
+        @@ optional_strings ~f:(fun x -> x = "key") [("key", `String "value"); ("key2", `String "value2")]
     );
 ]

data/tracks/perl6/config.json

@@ -16,6 +16,11 @@
 
   ],
   "exercises": [
+    {
+      "difficulty": 1,
+      "slug": "hello-world",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "bob",