trackler 2.0.0.8 → 2.0.0.9

data/tracks/ocaml/exercises/bob/test.ml

@@ -4,45 +4,58 @@ open Bob
 
 let ae exp got _test_ctxt = assert_equal ~printer:String.to_string exp got
 
-let tests =
-  ["something">::
-     ae "Whatever." (response_for "Tom-ay-to, tom-aaaah-to.");
-   "shouts">::
-     ae "Whoa, chill out!" (response_for "WATCH OUT!");
-   "questions">::
-     ae "Sure." (response_for "Does this cryogenic chamber make me look fat?");
-   "forceful talking">::
-     ae "Whatever." (response_for "Let's go make out behind the gym!");
-   "acronyms">::
-     ae "Whatever." (response_for "It's ok if you don't want to go to the DMV.");
-   "forceful questions">::
-     ae "Whoa, chill out!" (response_for "WHAT THE HELL WERE YOU THINKING?");
-   "shouting with special characters">::
-     ae "Whoa, chill out!"
-       (response_for "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!");
-   "shouting numbers">::
-     ae "Whoa, chill out!" (response_for "1, 2, 3, GO!");
-   "statement containing question mark">::
-     ae "Whatever." (response_for "Ending with ? means a question.");
-   "silence">::
-     ae "Fine. Be that way!" (response_for "");
-   "prolonged silence">::
-     ae "Fine. Be that way!" (response_for "   ");
-   "non-letters with question">::
-     ae "Sure." (response_for ":) ?");
-   "multiple line questons">::
-     ae "Whatever."
-       (response_for "\nDoes this cryogenic chamber make me look fat? \nno");
-   "other whitespace">::
-     (* No unicode whitespace as OCaml Core doesn't seem to handle Unicode.
-      * Not it seems does it see ASCII 11 (\v) as whitespace.
-     *)
-     ae "Fine. Be that way!" (response_for "\n\r \t");
-   "only numbers">::
-     ae "Whatever." (response_for "1, 2, 3");
-   "question with only numbers">::
-     ae "Sure." (response_for "4?");
-  ]
+let tests = [
+   "stating something" >::
+      ae "Whatever." (response_for "Tom-ay-to, tom-aaaah-to.");
+   "shouting" >::
+      ae "Whoa, chill out!" (response_for "WATCH OUT!");
+   "shouting gibberish" >::
+      ae "Whoa, chill out!" (response_for "FCECDFCAAB");
+   "asking a question" >::
+      ae "Sure." (response_for "Does this cryogenic chamber make me look fat?");
+   "asking a numeric question" >::
+      ae "Sure." (response_for "You are, what, like 15?");
+   "asking gibberish" >::
+      ae "Sure." (response_for "fffbbcbeab?");
+   "talking forcefully" >::
+      ae "Whatever." (response_for "Let's go make out behind the gym!");
+   "using acronyms in regular speech" >::
+      ae "Whatever." (response_for "It's OK if you don't want to go to the DMV.");
+   "forceful question" >::
+      ae "Whoa, chill out!" (response_for "WHAT THE HELL WERE YOU THINKING?");
+   "shouting numbers" >::
+      ae "Whoa, chill out!" (response_for "1, 2, 3 GO!");
+   "only numbers" >::
+      ae "Whatever." (response_for "1, 2, 3");
+   "question with only numbers" >::
+      ae "Sure." (response_for "4?");
+   "shouting with special characters" >::
+      ae "Whoa, chill out!" (response_for "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!");
+   "shouting with no exclamation mark" >::
+      ae "Whoa, chill out!" (response_for "I HATE YOU");
+   "statement containing question mark" >::
+      ae "Whatever." (response_for "Ending with ? means a question.");
+   "non-letters with question" >::
+      ae "Sure." (response_for ":) ?");
+   "prattling on" >::
+      ae "Sure." (response_for "Wait! Hang on. Are you going to be OK?");
+   "silence" >::
+      ae "Fine. Be that way!" (response_for "");
+   "prolonged silence" >::
+      ae "Fine. Be that way!" (response_for "          ");
+   "alternate silence" >::
+      ae "Fine. Be that way!" (response_for "\t\t\t\t\t\t\t\t\t\t");
+   "multiple line question" >::
+      ae "Whatever." (response_for "\nDoes this cryogenic chamber make me look fat?\nno");
+   "starting with whitespace" >::
+      ae "Whatever." (response_for "         hmmmmmmm...");
+   "ending with whitespace" >::
+      ae "Sure." (response_for "Okay if like my  spacebar  quite a bit?   ");
+   "other whitespace" >::
+      ae "Fine. Be that way!" (response_for "\n\r \t");
+   "non-question ending with whitespace" >::
+      ae "Whatever." (response_for "This is a statement ending with whitespace      ");
+]
 
 let () =
-  run_test_tt_main ("bob tests" >::: tests)
+  run_test_tt_main ("bob tests" >::: tests)

data/tracks/ocaml/exercises/hamming/test.ml

@@ -8,39 +8,49 @@ let printer n =
 let ae exp got _test_ctxt = assert_equal ~printer exp got
 
 let dna_of_string s =
-    let open Hamming in
-    let f = function
-        | 'A' -> A
-        | 'C' -> C
-        | 'G' -> G
-        | 'T' -> T
-        | _   -> failwith "Big news! New nucleotide discovered" in
-    String.to_list s |> List.map ~f
+  let open Hamming in
+  let f = function
+    | 'A' -> A
+    | 'C' -> C
+    | 'G' -> G
+    | 'T' -> T
+    | _   -> failwith "Big news! New nucleotide discovered" in
+  String.to_list s |> List.map ~f
 
 let hamdist a b = Hamming.hamming_distance (dna_of_string a) (dna_of_string b)
 
-let tests =
-  ["no difference between empty strands">::
-     ae (Some 0) (hamdist "" "");
-   "no difference between identical strands">::
-     ae (Some 0) (hamdist "GGACTAGA"
-                    "GGACTAGA");
-   "hamming distance in off by one strand">::
-     ae (Some 19) (hamdist "GGACGGATTCTGACCTGGACTAATTTTGGGGG"
-                     "AGGACGGATTCTGACCTGGACTAATTTTGGGG");
-   "small hamming distance in middle somewhere">::
-     ae (Some 1) (hamdist "GGACG"
-                    "GGTCG");
-   "larger distance">::
-     ae (Some 2) (hamdist "ACCAGGG"
-                    "ACTATGG");
-   "disallow first strand longer">::
-     ae None (hamdist "GACTACGGACAGGGTAGGGAAT"
-                "GACATCGCACACC");
-   "disallow second strand longer">::
-     ae None (hamdist "AAACTAGGGG"
-                "AGGCTAGCGGTAGGAC")
-  ]
+let tests = [
+   "identical strands" >::
+      ae (Some 0) (hamdist "A" "A");
+   "long identical strands" >::
+      ae (Some 0) (hamdist "GGACTGA" "GGACTGA");
+   "complete distance in single nucleotide strands" >::
+      ae (Some 1) (hamdist "A" "G");
+   "complete distance in small strands" >::
+      ae (Some 2) (hamdist "AG" "CT");
+   "small distance in small strands" >::
+      ae (Some 1) (hamdist "AT" "CT");
+   "small distance" >::
+      ae (Some 1) (hamdist "GGACG" "GGTCG");
+   "small distance in long strands" >::
+      ae (Some 2) (hamdist "ACCAGGG" "ACTATGG");
+   "non-unique character in first strand" >::
+      ae (Some 1) (hamdist "AGA" "AGG");
+   "non-unique character in second strand" >::
+      ae (Some 1) (hamdist "AGG" "AGA");
+   "same nucleotides in different positions" >::
+      ae (Some 2) (hamdist "TAG" "GAT");
+   "large distance" >::
+      ae (Some 4) (hamdist "GATACA" "GCATAA");
+   "large distance in off-by-one strand" >::
+      ae (Some 9) (hamdist "GGACGGATTCTG" "AGGACGGATTCT");
+   "empty strands" >::
+      ae (Some 0) (hamdist "" "");
+   "disallow first strand longer" >::
+      ae None (hamdist "AATG" "AAA");
+   "disallow second strand longer" >::
+      ae None (hamdist "ATA" "AGTG");
+]
 
 let () =
-  run_test_tt_main ("point-mutations tests" >::: tests)
+  run_test_tt_main ("hamming tests" >::: tests)

data/tracks/ocaml/exercises/raindrops/test.ml

@@ -4,45 +4,44 @@ open Raindrops
 
 let ae exp got _test_ctxt = assert_equal ~printer:Fn.id exp got
 
-let tests =
-  [
-    "raindrop 1">::
-    ae "1" (raindrop 1);
-    "raindrop 3">::
-    ae "Pling" (raindrop 3);
-    "raindrop 5">::
-    ae "Plang" (raindrop 5);
-    "raindrop 7">::
-    ae "Plong" (raindrop 7);
-    "raindrop 6">::
-    ae "Pling" (raindrop 6);
-    "raindrop 8">::
-    ae "8" (raindrop 8);
-    "raindrop 9">::
-    ae "Pling" (raindrop 9);
-    "raindrop 10">::
-    ae "Plang" (raindrop 10);
-    "raindrop 14">::
-    ae "Plong" (raindrop 14);
-    "raindrop 15">::
-    ae "PlingPlang" (raindrop 15);
-    "raindrop 21">::
-    ae "PlingPlong" (raindrop 21);
-    "raindrop 25">::
-    ae "Plang" (raindrop 25);
-    "raindrop 27">::
-    ae "Pling" (raindrop 27);
-    "raindrop 35">::
-    ae "PlangPlong" (raindrop 35);
-    "raindrop 49">::
-    ae "Plong" (raindrop 49);
-    "raindrop 52">::
-    ae "52" (raindrop 52);
-    "raindrop 105">::
-    ae "PlingPlangPlong" (raindrop 105);
-    "raindrop 3125">::
-    ae "Plang" (raindrop 3125);
+let tests = [
+   "the sound for 1 is 1" >::
+      ae "1" (raindrop 1);
+   "the sound for 3 is Pling" >::
+      ae "Pling" (raindrop 3);
+   "the sound for 5 is Plang" >::
+      ae "Plang" (raindrop 5);
+   "the sound for 7 is Plong" >::
+      ae "Plong" (raindrop 7);
+   "the sound for 6 is Pling as it has a factor 3" >::
+      ae "Pling" (raindrop 6);
+   "2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base" >::
+      ae "8" (raindrop 8);
+   "the sound for 9 is Pling as it has a factor 3" >::
+      ae "Pling" (raindrop 9);
+   "the sound for 10 is Plang as it has a factor 5" >::
+      ae "Plang" (raindrop 10);
+   "the sound for 14 is Plong as it has a factor of 7" >::
+      ae "Plong" (raindrop 14);
+   "the sound for 15 is PlingPlang as it has factors 3 and 5" >::
+      ae "PlingPlang" (raindrop 15);
+   "the sound for 21 is PlingPlong as it has factors 3 and 7" >::
+      ae "PlingPlong" (raindrop 21);
+   "the sound for 25 is Plang as it has a factor 5" >::
+      ae "Plang" (raindrop 25);
+   "the sound for 27 is Pling as it has a factor 3" >::
+      ae "Pling" (raindrop 27);
+   "the sound for 35 is PlangPlong as it has factors 5 and 7" >::
+      ae "PlangPlong" (raindrop 35);
+   "the sound for 49 is Plong as it has a factor 7" >::
+      ae "Plong" (raindrop 49);
+   "the sound for 52 is 52" >::
+      ae "52" (raindrop 52);
+   "the sound for 105 is PlingPlangPlong as it has factors 3, 5 and 7" >::
+      ae "PlingPlangPlong" (raindrop 105);
+   "the sound for 3125 is Plang as it has a factor 5" >::
+      ae "Plang" (raindrop 3125);
 ]
 
 let () =
-  run_test_tt_main ("raindrops tests" >::: tests)
+  run_test_tt_main ("raindrops tests" >::: tests)

data/tracks/ocaml/tools/test-generator/.merlin

@@ -0,0 +1,5 @@
+S src/**
+S test/**
+B _build/src
+B _build/test
+PKG core oUnit yojson

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

@@ -0,0 +1,15 @@
+test: test_gen.native
+	@./all_tests.native
+
+test_gen.native: all_tests.native
+	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg yojson -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src" test_gen.native
+
+all_tests.native: src/*.ml src/*.mli test/*.ml
+	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg oUnit -pkg yojson -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src,test" all_tests.native
+
+clean:
+	rm -rf _build
+	rm -f test_gen.native
+	rm -f all_tests.native
+
+.PHONY: clean

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

@@ -0,0 +1,17 @@
+open Core.Std
+
+open Model
+
+type fixup_function = key: string -> value: parameter -> string
+
+let replace_key (key: string) (value: string) (target: string): string =
+  String.substr_replace_all target ~pattern:("$" ^ key) ~with_:value
+
+let rec replace_keys (f: fixup_function) (s: string) (c: case): string =
+  let s = replace_key "name" c.name s in
+  let expected = f ~key:"expected" ~value:c.expected in
+  let s = replace_key "expected" expected s in
+  List.fold c.parameters ~init:s ~f:(fun s (k,v) -> replace_key k (parameter_to_string v) s)
+
+let generate_code (f: fixup_function) template cases =
+  Ok (List.map cases ~f:(replace_keys f template))

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

@@ -0,0 +1,7 @@
+open Core.Std
+
+open Model
+
+type fixup_function = key: string -> value: parameter -> string
+
+val generate_code : fixup_function -> string -> case list -> (string list, string) Result.t

data/tracks/ocaml/tools/test-generator/src/leap.json

@@ -0,0 +1,39 @@
+{
+   "cases": [
+      {
+         "description": "leap year",
+         "input": 1996,
+         "expected": true
+      },
+      {
+         "description": "standard and odd year",
+         "input": 1997,
+         "expected": false
+      },
+      {
+         "description": "standard even year",
+         "input": 1998,
+         "expected": false
+      },
+      {
+         "description": "standard nineteenth century",
+         "input": 1900,
+         "expected": false
+      },
+      {
+         "description": "standard eighteenth century",
+         "input": 1800,
+         "expected": false
+      },
+      {
+         "description": "leap twenty fourth century",
+         "input": 2400,
+         "expected": true
+      },
+      {
+         "description": "leap y2k",
+         "input": 2000,
+         "expected": true
+      }
+   ]
+}

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

@@ -0,0 +1,31 @@
+open Core.Std
+
+open Utils
+
+type parameter =
+  | String of string
+  | Float of float
+  | Int of int
+  | Bool of bool
+  | StringList of (string list)
+  | IntStringMap of ((string * int) list) [@@deriving eq, show]
+
+type 'a elements = (string * 'a) list [@@deriving eq, show]
+
+type case = {
+  name: string;
+  parameters: parameter elements;
+  expected: parameter;
+} [@@deriving eq, show]
+
+let surround (ch: char) (s: string): string =
+  Char.to_string ch ^ s ^ Char.to_string ch
+
+let parameter_to_string = function
+  | 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) ^ "]"
+  | IntStringMap xs -> "[" ^ String.concat ~sep:"; "
+                         (List.map xs ~f:(fun (k,v) -> "(\"" ^ String.escaped k ^ "\", " ^ Int.to_string v ^ ")")) ^ "]"

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

@@ -0,0 +1,61 @@
+open Core.Std
+open Utils
+open Yojson.Safe
+open Yojson.Safe.Util
+open Model
+
+type error =
+    TopLevelMustHaveKeyCalledCases | ExpectingListOfCases | ExpectingMapForCase |
+    BadDescription | BadExpected
+  [@@deriving eq]
+
+let to_int_unsafe = function
+  | `Int x -> x
+  | _ -> failwith "need an int here"
+
+let to_parameter (s: json) = match s with
+  | `String x -> Some (String x)
+  | `Float x -> Some (Float x)
+  | `Int x -> Some (Int x)
+  | `Bool x -> Some (Bool x)
+  | `List x -> Some (StringList (List.map x ~f:to_string))
+  | `Assoc x -> Some (IntStringMap (List.map x ~f:(fun (k,v) -> (k,to_int_unsafe v))))
+  | _ -> None
+
+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): (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
+  let test_parameters = List.Assoc.remove test_parameters "expected" in
+  let open Result.Monad_infix in
+  find "description" BadDescription >>=
+  to_string_note BadDescription >>= fun description ->
+  find "expected" BadExpected >>= fun expectedJson ->
+  to_parameter expectedJson |> Result.of_option ~error:BadExpected >>= fun expected ->
+  Ok {name = description; parameters = parse_parameters test_parameters; expected = expected}
+
+let parse_case (s: json): (case, error) Result.t = match s with
+  | `Assoc assoc -> parse_case_assoc assoc
+  | _ -> Error ExpectingMapForCase
+
+let parse_cases (text: string): (json, error) Result.t =
+  match from_string text |> member "cases" with
+    | `Null -> Error TopLevelMustHaveKeyCalledCases
+    | json -> Ok json
+
+let parse_json_text (text: string): (case list, error) Result.t =
+  let open Result.Monad_infix in
+  parse_cases text >>=
+  to_list_note ExpectingListOfCases >>=
+  (sequence >> (List.map ~f:parse_case))
+
+let show_error = function
+  | TopLevelMustHaveKeyCalledCases -> "Cannot parse this json - " ^
+      "expecting 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."

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

@@ -0,0 +1,9 @@
+open Core.Std
+open Model
+
+type error = TopLevelMustHaveKeyCalledCases | ExpectingListOfCases |
+             ExpectingMapForCase | BadDescription | BadExpected
+
+val parse_json_text : string -> (case list, error) Result.t
+
+val show_error : error -> string

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

@@ -0,0 +1,12 @@
+open Core.Std
+
+open Model
+
+let optional_int ~(none: int) = function
+  | Int n when n = none -> "None"
+  | Int n -> "(Some " ^ Int.to_string n ^ ")"
+  | _ -> failwith "can't handle non-int parameter"
+
+let fixup ~(stringify: parameter -> string) ~(slug: string) ~(key: string) ~(value: parameter) = match (slug, key) with
+  | ("hamming", "expected") -> optional_int (-1) value
+  | _ -> stringify value

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

@@ -0,0 +1,7 @@
+open Core.Std
+
+open Model
+
+val optional_int : none: int -> parameter -> string
+
+val fixup : stringify:(parameter -> string) -> slug:string -> key:string -> value:parameter -> string

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

@@ -0,0 +1,25 @@
+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:"Generates test code from canonical data."
+    Command.Spec.(
+      empty
+      +> flag "-t" (optional_with_default "./templates" is_directory) ~doc:"string Directory containing templates."
+      +> 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)
+
+let () =
+  Command.run ~version:"0.1" command

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

@@ -0,0 +1,62 @@
+open Core.Std
+open Parser
+open Model
+open Utils
+open Codegen
+open Special_cases
+
+let find_template ~(template_text: string): (int * int * string) 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 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 -> (s, s + 1 + Array.length l, String.concat_array l ~sep:"\n"))
+
+let splice_in_filled_in_code (start: int) (finish: int) ~(template: string) (substs: string list): string =
+  let lines = String.split_lines template |> List.to_array in
+  let before = Array.slice lines 0 start in
+  let subst = Array.of_list substs in
+  let after = Array.slice lines (finish + 1) (Array.length lines) in
+  let join = String.concat_array ~sep:"\n" in
+  String.concat [join before; join subst; join after] ~sep:"\n"
+
+type content = string
+
+let find_nested_files (name: string) (base: string): (string * content) list =
+  Sys.ls_dir base
+    |> List.filter ~f:(fun slug -> Sys.is_directory_exn (base ^ "/" ^ slug))
+    |> List.filter ~f:(fun slug -> Sys.file_exists_exn (base ^ "/" ^ slug ^ "/" ^ name))
+    |> List.map ~f:(fun slug -> (slug, In_channel.read_all (base ^ "/" ^ slug ^ "/" ^ name)))
+
+let find_templates = find_nested_files "template.ml"
+
+let find_canonical_data_files = find_nested_files "canonical-data.json"
+
+let combine_files (templates: (string * content) list) (canonical_data: (string * content) list): (string * content * content) list =
+  List.filter_map templates ~f:(fun (n,t) -> (List.Assoc.find canonical_data ~equal:String.equal n |> Option.map ~f:(fun c -> (n,t,c))))
+
+let generate_code ~slug ~template_file ~canonical_data_file =
+  let template = find_template template_file in
+  let template = Result.of_option template "cannot find a template" in
+  let cases = parse_json_text canonical_data_file in
+  let cases = Result.map_error cases show_error in
+  let open Result.Monad_infix in
+  template >>= fun (s,e,template) ->
+  cases >>= fun cs ->
+  let Ok substs = generate_code (fixup ~stringify:parameter_to_string ~slug) template cs in
+  Result.return (splice_in_filled_in_code s e ~template:template_file substs)
+
+let output_tests (files: (string * content * content) list) (output_folder: string): unit =
+  let output_filepath name = output_folder ^ "/" ^ name ^ "/test.ml" in
+  let output1 (slug,t,c) =
+    let Ok code = generate_code slug t c in
+    Out_channel.write_all (output_filepath slug) code in
+  List.iter files ~f:output1
+
+let run ~(templates_folder: string) ~(canonical_data_folder: string) ~(output_folder: string) =
+  let templates = find_templates templates_folder in
+  let canonical_data_files = find_canonical_data_files canonical_data_folder in
+  let combined = combine_files templates canonical_data_files in
+  output_tests combined output_folder

data/tracks/ocaml/tools/test-generator/src/test_generator.mli

@@ -0,0 +1,6 @@
+open Core.Std
+
+(* finds a template within a file, returning the line numbers of the comment starting and ending the template, and the body of the template *)
+val find_template : template_text: string -> (int * int * string) option
+
+val run : templates_folder: string -> canonical_data_folder: string -> output_folder: string -> unit

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

@@ -0,0 +1,32 @@
+open Core.Std
+open Yojson.Safe
+open Yojson.Safe.Util
+
+let map2 (f: 'a -> 'b -> 'c) (r1: ('a, 'e) Result.t) (r2: ('b, 'e) Result.t): ('c, 'e) Result.t = match (r1, r2) with
+  | (Error x, _) -> Error x
+  | (_, Error x) -> Error x
+  | (Ok a, Ok b) -> Ok (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 to_list_option json =
+  try Some (to_list json) with Type_error _ -> None
+
+let to_list_note error json =
+  try Ok (to_list 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 (>>) f g = Fn.compose f g
+
+let find_arrayi ?start:(start = 0) xs ~f =
+  let rec go i =
+    if i >= Array.length xs then None
+    else if f xs.(i) then Some (i, xs.(i))
+    else go (i + 1) in
+  go start

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

@@ -0,0 +1,18 @@
+open Core.Std
+open Yojson.Safe
+
+val map2 : ('a -> 'b -> 'c) -> ('a, 'e) Result.t -> ('b, 'e) Result.t -> ('c, 'e) Result.t
+
+val sequence : (('a, 'e) Result.t) list -> (('a list), 'e) Result.t
+
+val to_list_option : json -> json list option
+
+val to_list_note : 'e -> json -> ((json list, 'e) Result.t)
+
+val to_string_note : 'e -> json -> ((string, 'e) Result.t)
+
+val safe_to_int_option : json -> int option
+
+val find_arrayi : ?start:int -> 'a array -> f:('a -> bool) -> (int * 'a) option
+
+val (>>) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b