trackler 2.1.0.6 → 2.1.0.7

data/tracks/ocaml/exercises/triangle/example.ml

@@ -10,6 +10,6 @@ let is_triangle a b c =
 
 let is_equilateral a b c = is_triangle a b c && a = b && b = c
 
-let is_isoceles a b c = is_triangle a b c && (a = b || b = c || a = c)
+let is_isosceles a b c = is_triangle a b c && (a = b || b = c || a = c)
 
 let is_scalene a b c = is_triangle a b c && (a <> b && b <> c)

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

@@ -15,19 +15,19 @@ let equilateral_tests = [
      ae false (is_equilateral 0 0 0);
 ]
 
-let isoceles_tests = [
+let isosceles_tests = [
    "true if last two sides are equal" >::
-     ae true (is_isoceles 3 4 4);
+     ae true (is_isosceles 3 4 4);
    "true if first two sides are equal" >::
-     ae true (is_isoceles 4 4 3);
+     ae true (is_isosceles 4 4 3);
    "true if first and last sides are equal" >::
-     ae true (is_isoceles 4 3 4);
+     ae true (is_isosceles 4 3 4);
    "equilateral triangles are also isosceles" >::
-     ae true (is_isoceles 4 4 4);
+     ae true (is_isosceles 4 4 4);
    "false if no sides are equal" >::
-     ae false (is_isoceles 2 3 4);
+     ae false (is_isosceles 2 3 4);
    "Sides that violate triangle inequality are not isosceles, even if two are equal" >::
-     ae false (is_isoceles 1 1 3);
+     ae false (is_isosceles 1 1 3);
 ]
 
 let scalene_tests = [
@@ -44,5 +44,5 @@ let scalene_tests = [
 let () =
   run_test_tt_main (
     "triangle tests" >:::
-      List.concat [equilateral_tests; isoceles_tests; scalene_tests]
+      List.concat [equilateral_tests; isosceles_tests; scalene_tests]
   )

data/tracks/ocaml/exercises/triangle/triangle.mli

@@ -1,5 +1,5 @@
 val is_equilateral : int -> int -> int -> bool
 
-val is_isoceles : int -> int -> int -> bool
+val is_isosceles : int -> int -> int -> bool
 
 val is_scalene : int -> int -> int -> bool

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

@@ -11,10 +11,10 @@ let (* SUITE returns_true_if_the_triangle_is_equilateral *)equilateral_tests = [
    END TEST *)
 ]
 (* END SUITE *)
-let (* SUITE returns_true_if_the_triangle_is_isosceles *)isoceles_tests = [
+let (* SUITE returns_true_if_the_triangle_is_isosceles *)isosceles_tests = [
 (* TEST
    "$description" >::
-     ae $expected (is_isoceles $sides);
+     ae $expected (is_isosceles $sides);
    END TEST *)
 ]
 (* END SUITE *)
@@ -29,5 +29,5 @@ let (* SUITE returns_true_if_the_triangle_is_scalene *)scalene_tests = [
 let () =
   run_test_tt_main (
     "triangle tests" >:::
-      List.concat [equilateral_tests; isoceles_tests; scalene_tests]
+      List.concat [equilateral_tests; isosceles_tests; scalene_tests]
   )

data/tracks/perl6/exercises/all-your-base/AllYourBase.pm6

@@ -1 +1 @@
-unit module AllYourBase:ver<1>;
+unit module AllYourBase:ver<2>;

data/tracks/perl6/exercises/all-your-base/Example.pm

@@ -1,4 +1,4 @@
-unit module AllYourBase:ver<1>;
+unit module AllYourBase:ver<2>;
 
 class X::AllYourBase::InvalidBase is Exception {
   has $.payload;
@@ -18,7 +18,7 @@ sub convert-base (Int:D $input-base, @input-digits, Int:D $output-base --> Array
 }
 
 sub to-decimal ($input-base, @input-digits) {
-  return [] if !@input-digits;
+  return [].Slip if !@input-digits;
   my $elems = @input-digits.elems;
   for @input-digits {
     if $_ == 0 { $elems-- }

data/tracks/perl6/exercises/all-your-base/all-your-base.t

@@ -1,15 +1,17 @@
 #!/usr/bin/env perl6
 use v6;
 use Test;
-use lib $?FILE.IO.dirname;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Tiny;
 
 my $exercise = 'AllYourBase';
-my $version = v1;
+my $version = v2;
 my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
 plan 23;
 
 use-ok $module or bail-out;
 require ::($module);
+
 if ::($exercise).^ver !~~ $version {
   warn "\nExercise version mismatch. Further tests may fail!"
     ~ "\n$exercise is $(::($exercise).^ver.gist). "
@@ -17,147 +19,222 @@ if ::($exercise).^ver !~~ $version {
   bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
 }
 
-my @subs;
-BEGIN { @subs = <&convert-base> }
-subtest 'Subroutine(s)', {
-  plan 1;
-  eval-lives-ok "use $module; ::('$_').defined or die '$_ is not defined.'", $_ for @subs;
-} or bail-out 'All subroutines must be defined and exported.';
-require ::($module) @subs.eager;
-
-is convert-base(|.<input_base input_digits output_base>), |.<expected description> for @(my %cases.<valid>);
+require ::($module) <&convert-base>;
 
-my $exception = 'Exception';
-for @(%cases<invalid>) {
-  $exception = 'X::AllYourBase::Invalid' ~ (.<description> ~~ /«digit»/ ?? 'Digit' !! 'Base') if %*ENV<EXERCISM>;
-  throws-like {convert-base |.<input_base input_digits output_base>}, ::($exception), .<description>;
+my $c-data;
+sub test ($case, $expected) { is-deeply &::('convert-base')(|$case<input_base input_digits output_base>), $expected, $case<description> }
+for @($c-data<cases>) {
+  when .<expected> ~~ Array { test $_, .<expected> }
+  when .<description> ~~ /base|digit/ { throws-like {&::('convert-base')(|.<input_base input_digits output_base>)}, Exception, .<description> }
+  when .<description> eq 'leading zeros' { test $_, [4,2] }
+  when .<description> eq 'empty list' { test $_, [] }
+  when .<description> ~~ /zero/ { test $_, [0] }
+  default { flunk .<description> } # To ensure that no canonical-data cases are missed.
 }
 
+if %*ENV<EXERCISM> && (my $c-data-file =
+  "$dir/../../x-common/exercises/{$dir.IO.resolve.basename}/canonical-data.json".IO.resolve) ~~ :f
+{ is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data' } else { skip }
+
 done-testing;
 
 INIT {
-  require JSON::Tiny <&from-json>;
-  %cases := from-json ｢
-    {
-      "valid":[
-        { "description"  : "single bit one to decimal"
-        , "input_base"   : 2
-        , "input_digits" : [1]
-        , "output_base"  : 10
-        , "expected"     : [1]
-        },
-        { "description"  : "binary to single decimal"
-        , "input_base"   : 2
-        , "input_digits" : [1, 0, 1]
-        , "output_base"  : 10
-        , "expected"     : [5]
-        },
-        { "description"  : "single decimal to binary"
-        , "input_base"   : 10
-        , "input_digits" : [5]
-        , "output_base"  : 2
-        , "expected"     : [1, 0, 1]
-        },
-        { "description"  : "binary to multiple decimal"
-        , "input_base"   : 2
-        , "input_digits" : [1, 0, 1, 0, 1, 0]
-        , "output_base"  : 10
-        , "expected"     : [4, 2]
-        },
-        { "description"  : "decimal to binary"
-        , "input_base"   : 10
-        , "input_digits" : [4, 2]
-        , "output_base"  : 2
-        , "expected"     : [1, 0, 1, 0, 1, 0]
-        },
-        { "description"  : "trinary to hexadecimal"
-        , "input_base"   : 3
-        , "input_digits" : [1, 1, 2, 0]
-        , "output_base"  : 16
-        , "expected"     : [2, 10]
-        },
-        { "description"  : "hexadecimal to trinary"
-        , "input_base"   : 16
-        , "input_digits" : [2, 10]
-        , "output_base"  : 3
-        , "expected"     : [1, 1, 2, 0]
-        },
-        { "description"  : "15-bit integer"
-        , "input_base"   : 97
-        , "input_digits" : [3,46,60]
-        , "output_base"  : 73
-        , "expected"     : [6,10,45]
-        },
-        { "description"  : "empty list outputs empty list"
-        , "input_base"   : 2
-        , "input_digits" : []
-        , "output_base"  : 10
-        , "expected"     : []
-        },
-        { "description"  : "single zero outputs 0"
-        , "input_base"   : 10
-        , "input_digits" : [0]
-        , "output_base"  : 2
-        , "expected"     : [0]
-        },
-        { "description"  : "multiple zeros outputs 0"
-        , "input_base"   : 10
-        , "input_digits" : [0, 0, 0]
-        , "output_base"  : 2
-        , "expected"     : [0]
-        },
-        { "description"  : "leading zeros are stripped"
-        , "input_base"   : 7
-        , "input_digits" : [0, 6, 0]
-        , "output_base"  : 10
-        , "expected"     : [4, 2]
-      } ],
-      "invalid":[
-        { "description"  : "negative digit is invalid"
-        , "input_base"   : 2
-        , "input_digits" : [1, -1, 1, 0, 1, 0]
-        , "output_base"  : 10
-        },
-        { "description"  : "invalid positive digit"
-        , "input_base"   : 2
-        , "input_digits" : [1, 2, 1, 0, 1, 0]
-        , "output_base"  : 10
-        },
-        { "description"  : "first base is one"
-        , "input_base"   : 1
-        , "input_digits" : []
-        , "output_base"  : 10
-        },
-        { "description"  : "second base is one"
-        , "input_base"   : 2
-        , "input_digits" : [1, 0, 1, 0, 1, 0]
-        , "output_base"  : 1
-        },
-        { "description"  : "first base is zero"
-        , "input_base"   : 0
-        , "input_digits" : []
-        , "output_base"  : 10
-        },
-        { "description"  : "second base is zero"
-        , "input_base"   : 10
-        , "input_digits" : [7]
-        , "output_base"  : 0
-        },
-        { "description"  : "first base is negative"
-        , "input_base"   : -2
-        , "input_digits" : [1]
-        , "output_base"  : 10
-        },
-        { "description"  : "second base is negative"
-        , "input_base"   : 2
-        , "input_digits" : [1]
-        , "output_base"  : -7
-        },
-        { "description"  : "both bases are negative"
-        , "input_base"   : -2
-        , "input_digits" : [1]
-        , "output_base"  : -7
-      } ]
+$c-data := from-json q:to/END/;
+
+{
+  "exercise": "all-your-base",
+  "version": "1.0.0",
+  "comments": [
+    "It's up to each track do decide:",
+    "",
+    "1. What's the canonical representation of zero?",
+    " - []?",
+    " - [0]?",
+    "",
+    "2. What representations of zero are allowed?",
+    " - []?",
+    " - [0]?",
+    " - [0,0]?",
+    "",
+    "3. Are leading zeroes allowed?",
+    "",
+    "4. How should invalid input be handled?",
+    "",
+    "All the undefined cases are marked as null.",
+    "",
+    "All your numeric-base are belong to [2..]. :)"
+  ],
+  "cases": [
+    {
+      "description": "single bit one to decimal",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [1],
+      "output_base": 10,
+      "expected": [1]
+    },
+    {
+      "description": "binary to single decimal",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [1, 0, 1],
+      "output_base": 10,
+      "expected": [5]
+    },
+    {
+      "description": "single decimal to binary",
+      "property": "rebase",
+      "input_base": 10,
+      "input_digits": [5],
+      "output_base": 2,
+      "expected": [1, 0, 1]
+    },
+    {
+      "description": "binary to multiple decimal",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [1, 0, 1, 0, 1, 0],
+      "output_base": 10,
+      "expected": [4, 2]
+    },
+    {
+      "description": "decimal to binary",
+      "property": "rebase",
+      "input_base": 10,
+      "input_digits": [4, 2],
+      "output_base": 2,
+      "expected": [1, 0, 1, 0, 1, 0]
+    },
+    {
+      "description": "trinary to hexadecimal",
+      "property": "rebase",
+      "input_base": 3,
+      "input_digits": [1, 1, 2, 0],
+      "output_base": 16,
+      "expected": [2, 10]
+    },
+    {
+      "description": "hexadecimal to trinary",
+      "property": "rebase",
+      "input_base": 16,
+      "input_digits": [2, 10],
+      "output_base": 3,
+      "expected": [1, 1, 2, 0]
+    },
+    {
+      "description": "15-bit integer",
+      "property": "rebase",
+      "input_base": 97,
+      "input_digits": [3, 46, 60],
+      "output_base": 73,
+      "expected": [6, 10, 45]
+    },
+    {
+      "description": "empty list",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [],
+      "output_base": 10,
+      "expected": null
+    },
+    {
+      "description": "single zero",
+      "property": "rebase",
+      "input_base": 10,
+      "input_digits": [0],
+      "output_base": 2,
+      "expected": null
+    },
+    {
+      "description": "multiple zeros",
+      "property": "rebase",
+      "input_base": 10,
+      "input_digits": [0, 0, 0],
+      "output_base": 2,
+      "expected": null
+    },
+    {
+      "description": "leading zeros",
+      "property": "rebase",
+      "input_base": 7,
+      "input_digits": [0, 6, 0],
+      "output_base": 10,
+      "expected": null
+    },
+    {
+      "description": "negative digit",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [1, -1, 1, 0, 1, 0],
+      "output_base": 10,
+      "expected": null
+    },
+    {
+      "description": "invalid positive digit",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [1, 2, 1, 0, 1, 0],
+      "output_base": 10,
+      "expected": null
+    },
+    {
+      "description": "first base is one",
+      "property": "rebase",
+      "input_base": 1,
+      "input_digits": [],
+      "output_base": 10,
+      "expected": null
+    },
+    {
+      "description": "second base is one",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [1, 0, 1, 0, 1, 0],
+      "output_base": 1,
+      "expected": null
+    },
+    {
+      "description": "first base is zero",
+      "property": "rebase",
+      "input_base": 0,
+      "input_digits": [],
+      "output_base": 10,
+      "expected": null
+    },
+    {
+      "description": "second base is zero",
+      "property": "rebase",
+      "input_base": 10,
+      "input_digits": [7],
+      "output_base": 0,
+      "expected": null
+    },
+    {
+      "description": "first base is negative",
+      "property": "rebase",
+      "input_base": -2,
+      "input_digits": [1],
+      "output_base": 10,
+      "expected": null
+    },
+    {
+      "description": "second base is negative",
+      "property": "rebase",
+      "input_base": 2,
+      "input_digits": [1],
+      "output_base": -7,
+      "expected": null
+    },
+    {
+      "description": "both bases are negative",
+      "property": "rebase",
+      "input_base": -2,
+      "input_digits": [1],
+      "output_base": -7,
+      "expected": null
     }
-  ｣
+  ]
+}
+
+END
 }