trackler 2.0.8.17 → 2.0.8.18

data/common/exercises/variable-length-quantity/canonical-data.json

@@ -1,147 +1,177 @@
 {
-  "#": [
+  "exercise": "variable-length-quantity",
+  "version": "1.0.0",
+  "comments": [
     "JSON doesn't allow hexadecimal literals.",
     "All numbers are given as decimal literals instead.",
     "It is highly recommended that your track's test generator display all numbers as hexadecimal literals."
   ],
-  "encode": {
-    "description": ["Encode a series of integers, producing a series of bytes."],
-    "cases": [
-      {
-        "description": "zero",
-        "input": [0],
-        "expected": [0]
-      },
-      {
-        "description": "arbitrary single byte",
-        "input": [64],
-        "expected": [64]
-      },
-      {
-        "description": "largest single byte",
-        "input": [127],
-        "expected": [127]
-      },
-      {
-        "description": "smallest double byte",
-        "input": [128],
-        "expected": [129, 0]
-      },
-      {
-        "description": "arbitrary double byte",
-        "input": [8192],
-        "expected": [192, 0]
-      },
-      {
-        "description": "largest double byte",
-        "input": [16383],
-        "expected": [255, 127]
-      },
-      {
-        "description": "smallest triple byte",
-        "input": [16384],
-        "expected": [129, 128, 0]
-      },
-      {
-        "description": "arbitrary triple byte",
-        "input": [1048576],
-        "expected": [192, 128, 0]
-      },
-      {
-        "description": "largest triple byte",
-        "input": [2097151],
-        "expected": [255, 255, 127]
-      },
-      {
-        "description": "smallest quadruple byte",
-        "input": [2097152],
-        "expected": [129, 128, 128, 0]
-      },
-      {
-        "description": "arbitrary quadruple byte",
-        "input": [134217728],
-        "expected": [192, 128, 128, 0]
-      },
-      {
-        "description": "largest quadruple byte",
-        "input": [268435455],
-        "expected": [255, 255, 255, 127]
-      },
-      {
-        "description": "smallest quintuple byte",
-        "input": [268435456],
-        "expected": [129, 128, 128, 128, 0]
-      },
-      {
-        "description": "arbitrary quintuple byte",
-        "input": [4278190080],
-        "expected": [143, 248, 128, 128, 0]
-      },
-      {
-        "description": "maximum 32-bit integer input",
-        "input": [4294967295],
-        "expected": [143, 255, 255, 255, 127]
-      },
-      {
-        "description": "two single-byte values",
-        "input": [64, 127],
-        "expected": [64, 127]
-      },
-      {
-        "description": "two multi-byte values",
-        "input": [16384, 1193046],
-        "expected": [129, 128, 0, 200, 232, 86]
-      },
-      {
-        "description": "many multi-byte values",
-        "input": [8192, 1193046, 268435455, 0, 16383, 16384],
-        "expected": [192, 0, 200, 232, 86, 255, 255, 255, 127, 0, 255, 127, 129, 128, 0]
-      }
-    ]
-  },
-  "decode": {
-    "description": ["Decode a series of bytes, producing a series of integers."],
-    "cases": [
-      {
-        "description": "one byte",
-        "input": [127],
-        "expected": [127]
-      },
-      {
-        "description": "two bytes",
-        "input": [192, 0],
-        "expected": [8192]
-      },
-      {
-        "description": "three bytes",
-        "input": [255, 255, 127],
-        "expected": [2097151]
-      },
-      {
-        "description": "four bytes",
-        "input": [129, 128, 128, 0],
-        "expected": [2097152]
-      },
-      {
-        "description": "maximum 32-bit integer",
-        "input": [143, 255, 255, 255, 127],
-        "expected": [4294967295]
-      },
-      {
-        "description": "incomplete sequence causes error",
-        "input": [255],
-        "expected": null
-      },
-      {
-        "description": "incomplete sequence causes error, even if value is zero",
-        "input": [128],
-        "expected": null
-      },
-      {
-        "description": "multiple values",
-        "input": [192, 0, 200, 232, 86, 255, 255, 255, 127, 0, 255, 127, 129, 128, 0],
-        "expected": [8192, 1193046, 268435455, 0, 16383, 16384]
-      }
-    ]
-  }
+  "cases": [
+    {
+      "description": "Encode a series of integers, producing a series of bytes.",
+      "cases": [
+        {
+          "description": "zero",
+          "property": "encode",
+          "input": [0],
+          "expected": [0]
+        },
+        {
+          "description": "arbitrary single byte",
+          "property": "encode",
+          "input": [64],
+          "expected": [64]
+        },
+        {
+          "description": "largest single byte",
+          "property": "encode",
+          "input": [127],
+          "expected": [127]
+        },
+        {
+          "description": "smallest double byte",
+          "property": "encode",
+          "input": [128],
+          "expected": [129,0]
+        },
+        {
+          "description": "arbitrary double byte",
+          "property": "encode",
+          "input": [8192],
+          "expected": [192, 0]
+        },
+        {
+          "description": "largest double byte",
+          "property": "encode",
+          "input": [16383],
+          "expected": [255, 127]
+        },
+        {
+          "description": "smallest triple byte",
+          "property": "encode",
+          "input": [16384],
+          "expected": [129, 128, 0]
+        },
+        {
+          "description": "arbitrary triple byte",
+          "property": "encode",
+          "input": [1048576],
+          "expected": [192, 128, 0]
+        },
+        {
+          "description": "largest triple byte",
+          "property": "encode",
+          "input": [2097151],
+          "expected": [255, 255, 127]
+        },
+        {
+          "description": "smallest quadruple byte",
+          "property": "encode",
+          "input": [2097152],
+          "expected": [129, 128, 128, 0]
+        },
+        {
+          "description": "arbitrary quadruple byte",
+          "property": "encode",
+          "input": [134217728],
+          "expected": [192, 128, 128, 0]
+        },
+        {
+          "description": "largest quadruple byte",
+          "property": "encode",
+          "input": [268435455],
+          "expected": [255, 255, 255, 127]
+        },
+        {
+          "description": "smallest quintuple byte",
+          "property": "encode",
+          "input": [268435456],
+          "expected": [129, 128, 128, 128, 0]
+        },
+        {
+          "description": "arbitrary quintuple byte",
+          "property": "encode",
+          "input": [4278190080],
+          "expected": [143, 248, 128, 128, 0]
+        },
+        {
+          "description": "maximum 32-bit integer input",
+          "property": "encode",
+          "input": [4294967295],
+          "expected": [143, 255, 255, 255, 127]
+        },
+        {
+          "description": "two single-byte values",
+          "property": "encode",
+          "input": [64, 127],
+          "expected": [64, 127]
+        },
+        {
+          "description": "two multi-byte values",
+          "property": "encode",
+          "input": [16384, 1193046],
+          "expected": [129, 128, 0, 200, 232, 86]
+        },
+        {
+          "description": "many multi-byte values",
+          "property": "encode",
+          "input": [8192, 1193046, 268435455, 0, 16383, 16384],
+          "expected": [192, 0, 200, 232, 86, 255, 255, 255, 127, 0, 255, 127, 129, 128, 0]
+        }
+      ]
+    },
+    {
+      "description": "Decode a series of bytes, producing a series of integers.",
+      "cases": [
+        {
+          "description": "one byte",
+          "property": "decode",
+          "input": [127],
+          "expected": [127]
+        },
+        {
+          "description": "two bytes",
+          "property": "decode",
+          "input": [192, 0],
+          "expected": [8192]
+        },
+        {
+          "description": "three bytes",
+          "property": "decode",
+          "input": [255, 255, 127],
+          "expected": [2097151]
+        },
+        {
+          "description": "four bytes",
+          "property": "decode",
+          "input": [129, 128, 128, 0],
+          "expected": [2097152]
+        },
+        {
+          "description": "maximum 32-bit integer",
+          "property": "decode",
+          "input": [143, 255, 255, 255, 127],
+          "expected": [4294967295]
+        },
+        {
+          "description": "incomplete sequence causes error",
+          "property": "decode",
+          "input": [255],
+          "expected": null
+        },
+        {
+          "description": "incomplete sequence causes error, even if value is zero",
+          "property": "decode",
+          "input": [128],
+          "expected": null
+        },
+        {
+          "description": "multiple values",
+          "property": "decode",
+          "input": [192, 0, 200, 232, 86, 255, 255, 255, 127, 0, 255, 127, 129, 128, 0],
+          "expected": [8192, 1193046, 268435455, 0, 16383, 16384]
+        }
+      ]
+    }
+  ]
 }

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.17"
+  VERSION = "2.0.8.18"
 end

data/tracks/csharp/exercises/diamond/HINTS.md

@@ -0,0 +1,9 @@
+## Hints
+The tests in this exercise are different from your usual tests. Normally, a test checks if for a given input, the output matches the expected value. This is called *value-based testing*. However, this exercise uses *property-based testing*, where the tests check if for a range of inputs, the output has a specific property. The two key differences that differentiate property-based testing from value-based testing are:
+
+1. A property-based test works not with a single input value, but with many.
+1. A property-based test verifies properties, not concrete values.
+
+For this exercise, the tests all verify a property of the diamond shape your code should be producing. Furthermore, all tests check if the property they test holds for all valid input letters ('A' to 'Z').
+
+For more information on property-based testing, see [this article](http://www.erikschierboom.com/2016/02/22/property-based-testing/).

data/tracks/go/README.md

@@ -26,6 +26,9 @@ Test your clone by cding to the xgo directory and typing
 Note that unlike most other Go code, it is not necessary to clone this to your GOPATH.
 This is because this repo only imports from the standard library and isn't expected to be imported by other packages.
 
+There is a [misspelling tool](https://github.com/client9/misspell). You can install and occasionally run it to
+find low hanging typo problems. [#570](https://github.com/exercism/xgo/pull/570) It's not added into CI since it could give false positives.
+
 ## Contributing Guide
 
 Please be familiar with the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md)

data/tracks/go/exercises/queen-attack/queen_attack_test.go

@@ -33,7 +33,7 @@ var tests = []struct {
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
 	}
 }
 

data/tracks/haskell/exercises/hamming/src/Hamming.hs

@@ -1,3 +1,4 @@
 module Hamming (distance) where
 
-distance = error "You need to implement this function."
+distance :: String -> String -> Maybe Int
+distance xs ys = error "You need to implement this function."

data/tracks/java/exercises/flatten-array/src/test/java/FlattenerTest.java

@@ -1,5 +1,6 @@
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.Ignore;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
@@ -32,6 +33,7 @@ public final class FlattenerTest {
               8)));
     }
 
+    @Ignore
     @Test
     public void testFiveLevelsOfNestingWithNoNulls() {
         assertEquals(
@@ -54,6 +56,7 @@ public final class FlattenerTest {
               "-2")));
     }
 
+    @Ignore
     @Test
     public void testSixLevelsOfNestingWithNoNulls() {
         assertEquals(
@@ -76,6 +79,7 @@ public final class FlattenerTest {
               "8")));
     }
 
+    @Ignore
     @Test
     public void testSixLevelsOfNestingWithNulls() {
         assertEquals(
@@ -99,6 +103,7 @@ public final class FlattenerTest {
               "negative two")));
     }
 
+    @Ignore
     @Test
     public void testNestedListsFullOfNullsOnly() {
         assertEquals(

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

@@ -13,13 +13,13 @@ let tests = [
     ae ["tan"] (anagrams "ant" ["tan"; "stand"; "at"]);
   "does not detect false positives" >::
     ae [] (anagrams "galea" ["eagle"]);
-  "detects multiple anagrams" >::
+  "detects two anagrams" >::
     ae ["stream"; "maters"] (anagrams "master" ["stream"; "pigeon"; "maters"]);
   "does not detect anagram subsets" >::
     ae [] (anagrams "good" ["dog"; "goody"]);
   "detects anagram" >::
     ae ["inlets"] (anagrams "listen" ["enlists"; "google"; "inlets"; "banana"]);
-  "detects multiple anagrams" >::
+  "detects three anagrams" >::
     ae ["gallery"; "regally"; "largely"] (anagrams "allergy" ["gallery"; "ballerina"; "regally"; "clergy"; "largely"; "leading"]);
   "does not detect identical words" >::
     ae ["cron"] (anagrams "corn" ["corn"; "dark"; "Corn"; "rank"; "CORN"; "cron"; "park"]);

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

@@ -22,6 +22,12 @@ let find_canonical_data_files = find_nested_files "canonical-data.json"
 let combine_files (template_files: (string * content) list) (canonical_data_files: (string * content) list): (string * content * content) list =
   List.filter_map template_files ~f:(fun (n,t) -> (List.Assoc.find canonical_data_files ~equal:String.equal n |> Option.map ~f:(fun c -> (n,t,c))))
 
+(* pangram in the canonical data is a suite but it does not really need to be as there's only one group. Convert a Suite to
+   a Single test in this case, to simplify the template. *)
+let simplify_single_test_suite tests = match tests with
+| Suite [{name = name; cases = cases}] -> Single cases
+| x -> x
+
 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:json_to_string ~slug in
@@ -30,7 +36,7 @@ let generate_code ~(slug: string) ~(template_file: content) ~(canonical_data_fil
   let open Result.Monad_infix in
   Result.of_option template ("cannot recognize file for " ^ slug ^ " as a template") >>= fun template ->
   parse_json_text canonical_data_file (expected_key_name slug) (cases_name slug)
-  |> Result.map_error ~f:show_error >>= (function
+  |> Result.map_error ~f:show_error >>| simplify_single_test_suite >>= (function
       | Single cases ->
         fill_in_template template.template slug cases
         |> fill_tests template
@@ -38,7 +44,6 @@ let generate_code ~(slug: string) ~(template_file: content) ~(canonical_data_fil
       | Suite tests ->
         List.map tests ~f:(fun {name;cases} -> (name, fill_in_template template.template name cases))
         |> fill_suite template
-        |> Result.return
     )
 
 let output_tests (files: (string * content * content) list) (output_folder: string) ~(generated_folder: string): unit =

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

@@ -24,7 +24,7 @@ let parse_case (expected_key: string) (s: json): (case, error) Result.t = match
 
 let parse_cases (text: string) (cases_key: string): (json, error) Result.t =
   match from_string text |> member cases_key with
-    | `Null -> Error (TestMustHaveKeyCalledCases "xx")
+    | `Null -> Error (TestMustHaveKeyCalledCases cases_key)
     | json -> Ok json
 
 let parse_single (text: string) (expected_key: string) (cases_key: string): (tests, error) Result.t =
@@ -34,15 +34,34 @@ let parse_single (text: string) (expected_key: string) (cases_key: string): (tes
   (sequence >> (List.map ~f:(parse_case expected_key))) >>= fun ts ->
   Result.return (Single ts)
 
-let is_suite (json: json) (cases_key: string) =
-  let ignorable_keys = ["exercise"; "version"; "methods"; "comments"] in
-  let keys = List.filter (keys json) ~f:(Fn.non (List.mem ignorable_keys)) in
-  let keys = List.sort keys ~cmp:String.compare in
-  not (List.is_empty keys || keys = [cases_key] || keys = ["#"; cases_key])
+let rec to_cases case: (case list, error) Result.t = 
+  let open Result.Monad_infix in
+  find_note case "description" NoDescription >>= to_string_note BadDescription >>= fun desc ->
+  let cases = List.Assoc.find case "cases" in
+  match cases with
+  | Some cases -> to_list_note UnrecognizedJson cases >>= fun cases ->
+      List.map cases ~f:(to_assoc_note UnrecognizedJson) |> sequence >>= fun x ->
+      List.map x ~f:to_cases |> sequence |> Result.map ~f:List.concat
+  | None -> 
+      find_note case "expected" (NoExpected "expected") >>= fun expected ->
+      Result.return [{description = desc; parameters = case; expected = expected}]
+
+let convert_cases_description_to_name desc =
+  String.lowercase desc |> String.substr_replace_all ~pattern:" " ~with_:"_"
 
-let merge_result = function
-  | (_, Error x) -> Error x
-  | (n, Ok c) -> Ok {name = n; cases = c}
+let suite_case json: (test, error) Result.t = 
+  let open Result.Monad_infix in
+  to_assoc_note UnrecognizedJson json >>= fun case ->
+  find_note case "description" NoDescription >>= to_string_note BadDescription >>= fun desc ->
+  find_note case "cases" ExpectingListOfCases >>= to_list_note ExpectingListOfCases >>= fun case_assocs ->
+  List.map ~f:(to_assoc_note ExpectingMapForCase) case_assocs |> sequence >>= fun cases -> 
+  List.map cases ~f:to_cases |> sequence >>= fun cases ->
+  Result.return {name = convert_cases_description_to_name desc; cases = List.concat cases}
+
+let suite_cases (json: json) (cases_key: string): (test list, error) Result.t = 
+  let open Result.Monad_infix in
+  (member cases_key json |> to_list_note ExpectingListOfCases) >>= fun assoc_cases ->
+  List.map ~f:suite_case assoc_cases |> sequence
 
 let parse_cases_from_suite name suite expected_key cases_key =
   let open Result.Monad_infix in
@@ -53,15 +72,9 @@ let parse_cases_from_suite name suite expected_key cases_key =
 let parse_json_text (text: string) (expected_key: string) (cases_key: string): (tests, error) Result.t =
   let open Result.Monad_infix in
   let json = from_string text in
-  if is_suite json cases_key
-  then
-    to_assoc_note UnrecognizedJson json >>= 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 expected_key cases_key)) in
-    sequence tests >>= fun tests ->
-    Ok (Suite tests)
-  else
-    parse_single text expected_key cases_key
+  match suite_cases json cases_key with
+  | Ok suite_cases -> Ok (Suite suite_cases)
+  | Error _ -> parse_single text expected_key cases_key
 
 let show_error = function
   | TestMustHaveKeyCalledCases name -> "Test named '" ^ name ^ "' is expected to have an object with a key: 'cases'"

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

@@ -40,21 +40,23 @@ let fill_tests (template: t) (substs: subst list): string =
   let join = String.concat_array ~sep:"\n" in
   String.concat [join before; join subst; join after] ~sep:"\n"
 
-let fill_single_suite (template: t) (suite_substs: string * subst list): string =
+let fill_single_suite (template: t) (suite_substs: string * subst list): (string, string) Result.t =
+  let open Result.Monad_infix in
   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
+  Result.of_option template.suite_name_line ~error:"no suite name" >>= fun suite_name_line ->
+  Result.of_option template.suite_end ~error:"no suite end" >>= fun suite_end_line ->
   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"
+  Result.return @@ (String.concat [join before; join subst; join after] ~sep:"\n") ^ "\n"
 
-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 fill_suite (template: t) (suite_substs: (string * subst list) list): (string, string) Result.t =
+  let open Result.Monad_infix in
+  List.map suite_substs ~f:(fun x -> (fill_single_suite template x)) |> sequence >>= fun fills ->
+  Result.of_option template.suite_name_line "no suite name line" >>= fun suite_name_line ->
   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
@@ -62,4 +64,4 @@ let fill_suite (template: t) (suite_substs: (string * subst list) list): string
   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
+  Result.return @@ String.substr_replace_all generated ~pattern:"(* suite-all-names *)" ~with_:all_suite_names

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

@@ -27,15 +27,26 @@ let to_list_note error json =
 let to_assoc_note error json =
   try Ok (to_assoc json) with Type_error _ -> Error error
 
+let to_assoc_option json =
+  try Some (to_assoc json) with Type_error _ -> None
+
 let to_string_note error json =
   try Ok (to_string json) with Type_error _ -> Error error
 
+let to_string_option json =
+  try Some (to_string json) with _ -> None
+
 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 find_note (xs: ('a, 'b) List.Assoc.t) (key: 'a) (error: 'e): ('b, 'e) Result.t = 
+  match List.Assoc.find xs key with
+  | Some v -> Ok v
+  | None -> Error error
+
 let (>>) f g = Fn.compose f g
 
 let find_arrayi ?start:(start = 0) xs ~f =

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

@@ -9,13 +9,12 @@ let option_to_string f = function
 let ae exp got _test_ctxt =
   assert_equal ~printer:(option_to_string String.to_string) exp got
 
-let (* SUITE *)$(suite_name)_tests = [
+let tests = [
 (* TEST
-   "$description" >::
-      ae $expected (number $phrase);
-   END TEST *)
+  "$description" >::
+    ae $expected (number $phrase);
+END TEST *)
 ]
-(* END SUITE *)
 
 let () =
   run_test_tt_main ("phone-number tests" >::: number_tests)