trackler 2.0.8.28 → 2.0.8.29

data/tracks/perl6/exercises/allergies/allergies.t

@@ -1,155 +1,205 @@
 #!/usr/bin/env perl6
-
+use v6;
 use Test;
+use lib my $dir = $?FILE.IO.dirname;
 use JSON::Tiny;
 
-use lib $?FILE.IO.dirname;
-
-my $module = %*ENV<EXERCISM> ?? 'Example' !! 'Allergies';
-require ::($module) <&allergic-to &list-allergies>;
+my $exercise = 'Allergies';
+my $version = v1;
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
+plan 5;
 
-plan 2;
-
-my %cases;
-subtest 'allergic-to' => {
-    my @cases = |%cases{'allergic_to'}{'cases'};
+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). "
+    ~ "Test is $($version.gist).\n";
+  bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
+}
 
-    plan +@cases;
+my @subs;
+BEGIN { @subs = <&allergic-to &list-allergies> };
+subtest 'Subroutine(s)', {
+  plan 2;
+  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;
 
-    for |@cases -> %case {
-        subtest %case.<description> => {
-            plan +|%case.<expected>;
-            for |%case.<expected> -> %expected {
-                is allergic-to(%case.<score>,%expected.<substance>), %expected.<result>
-                    or diag %expected;
-            }
-        }
+for @(my $c-data.<cases>) -> %cases {
+  subtest 'allergic-to' => {
+    plan 7;
+    my @cases = |%cases<cases>;
+    for @cases -> %case {
+      is allergic-to(%case<score>, .<substance>), .<result>, %case<description> for @(%case<expected>);
     }
-};
-
-subtest 'list' => {
-    my @cases = |%cases{'list'}{'cases'};
+  } if %cases<description> ~~ 'allergicTo';
 
-    plan +@cases;
-
-    for |@cases {
-        is list-allergies(.<score>), .<expected>, .<description>
-            or diag $_;
+  subtest 'list-allergies' => {
+    plan 9;
+    my @cases = |%cases<cases>;
+    for @cases {
+      is list-allergies(.<score>), |.<expected description>;
     }
-};
+  } if %cases<description> ~~ 'list';
+}
+
+if %*ENV<EXERCISM> && (my $c-data-file = "$dir/../../x-common/exercises/{$dir.IO.basename}/canonical-data.json".IO.resolve) ~~ :f {
+  is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data'
+} else { skip }
 
 done-testing;
 
 INIT {
-  %cases := from-json ｢
+  $c-data := from-json ｢
     {
-      "allergic_to": {
-        "description": [
-          "Given a number and a substance, indicate whether Tom is allergic ",
-          "to that substance.",
-          "Test cases for this method involve more than one assertion.",
-          "Each case in 'expected' specifies what the method should return for",
-          "the given substance."
-        ],
-        "cases": [
-          {
-            "description": "no allergies means not allergic",
-            "score": 0,
-            "expected": [
-              {
-                "substance": "peanuts",
-                "result": false
-              },
-              {
-                "substance": "cats",
-                "result": false
-              },
-              {
-                "substance": "strawberries",
-                "result": false
-              }
-            ]
-          },
-          {
-            "description": "is allergic to eggs",
-            "score": 1,
-            "expected": [
-              {
-                "substance": "eggs",
-                "result": true
-              }
-            ]
-          },
-          {
-            "description": "allergic to eggs in addition to other stuff",
-            "score": 5,
-            "expected": [
-              {
-                "substance": "eggs",
-                "result": true
-              },
-              {
-                "substance": "shellfish",
-                "result": true
-              },
-              {
-                "substance": "strawberries",
-                "result": false
-              }
-            ]
-          }
-        ]
-      },
-      "list": {
-        "description": ["Given a number, list all things Tom is allergic to"],
-        "cases": [
-          {
-            "description": "no allergies at all",
-            "score": 0,
-            "expected": []
-          },
-          {
-            "description": "allergic to just eggs",
-            "score": 1,
-            "expected": ["eggs"]
-          },
-          {
-            "description": "allergic to just peanuts",
-            "score": 2,
-            "expected": ["peanuts"]
-          },
-          {
-            "description": "allergic to just strawberries",
-            "score": 8,
-            "expected": ["strawberries"]
-          },
-          {
-            "description": "allergic to eggs and peanuts",
-            "score": 3,
-            "expected": ["eggs", "peanuts"]
-          },
-          {
-            "description": "allergic to more than eggs but not peanuts",
-            "score": 5,
-            "expected": ["eggs", "shellfish"]
-          },
-          {
-            "description": "allergic to lots of stuff",
-            "score": 248,
-            "expected": ["strawberries", "tomatoes", "chocolate", "pollen", "cats"]
-          },
-          {
-            "description": "allergic to everything",
-            "score": 255,
-            "expected": ["eggs", "peanuts", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats"]
-          },
-          {
-            "description": "ignore non allergen score parts",
-            "score": 509,
-            "expected": ["eggs", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats"]
-          }
-        ]
-      }
+      "exercise": "allergies",
+      "version": "1.0.0",
+      "cases": [
+        {
+          "description": "allergicTo",
+          "comments": [
+            "Given a number and a substance, indicate whether Tom is allergic ",
+            "to that substance.",
+            "Test cases for this method involve more than one assertion.",
+            "Each case in 'expected' specifies what the method should return for",
+            "the given substance."
+          ],
+          "cases": [
+            {
+              "description": "no allergies means not allergic",
+              "property": "allergicTo",
+              "score": 0,
+              "expected": [
+                {
+                  "substance": "peanuts",
+                  "result": false
+                },
+                {
+                  "substance": "cats",
+                  "result": false
+                },
+                {
+                  "substance": "strawberries",
+                  "result": false
+                }
+              ]
+            },
+            {
+              "description": "is allergic to eggs",
+              "property": "allergicTo",
+              "score": 1,
+              "expected": [
+                {
+                  "substance": "eggs",
+                  "result": true
+                }
+              ]
+            },
+            {
+              "description": "allergic to eggs in addition to other stuff",
+              "property": "allergicTo",
+              "score": 5,
+              "expected": [
+                {
+                  "substance": "eggs",
+                  "result": true
+                },
+                {
+                  "substance": "shellfish",
+                  "result": true
+                },
+                {
+                  "substance": "strawberries",
+                  "result": false
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "description": "list",
+          "comments": [
+            "Given a number, list all things Tom is allergic to"
+          ],
+          "cases": [
+            {
+              "description": "no allergies at all",
+              "property": "list",
+              "score": 0,
+              "expected": []
+            },
+            {
+              "description": "allergic to just eggs",
+              "property": "list",
+              "score": 1,
+              "expected": ["eggs"]
+            },
+            {
+              "description": "allergic to just peanuts",
+              "property": "list",
+              "score": 2,
+              "expected": ["peanuts"]
+            },
+            {
+              "description": "allergic to just strawberries",
+              "property": "list",
+              "score": 8,
+              "expected": ["strawberries"]
+            },
+            {
+              "description": "allergic to eggs and peanuts",
+              "property": "list",
+              "score": 3,
+              "expected": ["eggs", "peanuts"]
+            },
+            {
+              "description": "allergic to more than eggs but not peanuts",
+              "property": "list",
+              "score": 5,
+              "expected": ["eggs", "shellfish"]
+            },
+            {
+              "description": "allergic to lots of stuff",
+              "property": "list",
+              "score": 248,
+              "expected": [ "strawberries",
+                            "tomatoes",
+                            "chocolate",
+                            "pollen",
+                            "cats"
+                          ]
+            },
+            {
+              "description": "allergic to everything",
+              "property": "list",
+              "score": 255,
+              "expected": [ "eggs",
+                            "peanuts",
+                            "shellfish",
+                            "strawberries",
+                            "tomatoes",
+                            "chocolate",
+                            "pollen",
+                            "cats"
+                          ]
+            },
+            {
+              "description": "ignore non allergen score parts",
+              "property": "list",
+              "score": 509,
+              "expected": [ "eggs",
+                            "shellfish",
+                            "strawberries",
+                            "tomatoes",
+                            "chocolate",
+                            "pollen",
+                            "cats"
+                          ]
+            }
+          ]
+        }
+      ]
     }
   ｣
 }

data/tracks/perl6/exercises/anagram/Anagram.pm6

@@ -0,0 +1 @@
+unit module Anagram:ver<1>;

data/tracks/perl6/exercises/anagram/Example.pm

@@ -1,18 +1,18 @@
-class Anagram is export {
-    method match ($word, @words) {
-        my @results;
-        my $canonical = self!canonize($word);
-        for @words -> $w {
-            next if $w.lc eq $word.lc;
-            my $try = self!canonize($w);
-            if $try eq $canonical {
-                @results.push: $w;
-            }
-        }
-        @results;
-    }
+unit module Anagram:ver<1>;
 
-    method !canonize($str) {
-        (($str.lc.split('')).sort).join('');
+sub match-anagrams ($word, @words) is export {
+  my @results;
+  my $canonical = canonize($word);
+  for @words -> $w {
+    next if $w.lc eq $word.lc;
+    my $try = canonize($w);
+    if $try eq $canonical {
+      @results.push: $w;
     }
+  }
+  @results;
+}
+
+sub canonize ($str) {
+  (($str.lc.split('')).sort).join('');
 }

data/tracks/perl6/exercises/anagram/anagram.t

@@ -1,21 +1,170 @@
 #!/usr/bin/env perl6
 use v6;
 use Test;
-use lib IO::Path.new($?FILE).parent.path;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Tiny;
 
-plan 11;
-my $module = %*ENV<EXERCISM> ?? 'Example' !! 'Anagram';
-use-ok $module;
-require ::($module) <Anagram>;
+my $exercise = 'Anagram';
+my $version = v1;
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
+plan 19;
 
-ok Anagram.can('match'), 'Class Anagram has match method';
+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). "
+    ~ "Test is $($version.gist).\n";
+  bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
+}
 
-is-deeply Anagram.match('diaper', ['hello', 'world', 'zombies', 'pants']), [], 'no matches';
-is-deeply Anagram.match('ant', ['tan', 'stand', 'at']), ['tan'], 'detect simple anagram';
-is-deeply Anagram.match('master', ['stream', 'pigeon', 'maters']), ['stream', 'maters'], 'multiple anagrams';
-is-deeply Anagram.match('galea', ['eagle']), [], 'does not confuse different duplicates';
-is-deeply Anagram.match('good', ['dog', 'goody']), [], 'eleminates anagram subsets';
-is-deeply Anagram.match('listen', ['enlists', 'google', 'inlets', 'banana']), ['inlets'], 'detect anagram';
-is-deeply Anagram.match('allergy', ['gallery', 'ballerina', 'regally', 'clergy', 'largely', 'leading']), ['gallery', 'regally', 'largely'], 'multiple anagrams';
-is-deeply Anagram.match('Orchestra', ['cashregister', 'Carthorse', 'radishes']), ['Carthorse'], 'anagrams are case-insensitive';
-is-deeply Anagram.match('banana', ['banana', 'Banana']), [], 'same word is not an anagram, whatever the case';
+my @subs;
+BEGIN { @subs = <&match-anagrams> };
+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 match-anagrams(|.<subject candidates>), |.<expected description> for @(my $c-data.<cases>);
+
+if %*ENV<EXERCISM> && (my $c-data-file = "$dir/../../x-common/exercises/{$dir.IO.basename}/canonical-data.json".IO.resolve) ~~ :f {
+  is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data'
+} else { skip }
+
+done-testing;
+
+INIT {
+  $c-data := from-json ｢
+    {
+      "exercise": "anagram",
+      "version": "1.0.1",
+      "comments": [
+        "The string argument cases possible matches are passed in as",
+        "individual arguments rather than arrays. Languages can include",
+        "these string argument cases if passing individual arguments is",
+        "idiomatic in that language."
+      ],
+      "cases": [
+        {
+          "description": "no matches",
+          "property": "anagrams",
+          "subject": "diaper",
+          "candidates": ["hello", "world", "zombies", "pants"],
+          "expected": []
+        },
+        {
+          "description": "detects simple anagram",
+          "property": "anagrams",
+          "subject": "ant",
+          "candidates": ["tan", "stand", "at"],
+          "expected": ["tan"]
+        },
+        {
+          "description": "does not detect false positives",
+          "property": "anagrams",
+          "subject": "galea",
+          "candidates": ["eagle"],
+          "expected": []
+        },
+        {
+          "description": "detects two anagrams",
+          "property": "anagrams",
+          "subject": "master",
+          "candidates": ["stream", "pigeon", "maters"],
+          "expected": ["stream", "maters"]
+        },
+        {
+          "description": "does not detect anagram subsets",
+          "property": "anagrams",
+          "subject": "good",
+          "candidates": ["dog", "goody"],
+          "expected": []
+        },
+        {
+          "description": "detects anagram",
+          "property": "anagrams",
+          "subject": "listen",
+          "candidates": ["enlists", "google", "inlets", "banana"],
+          "expected": ["inlets"]
+        },
+        {
+          "description": "detects three anagrams",
+          "property": "anagrams",
+          "subject": "allergy",
+          "candidates": [ "gallery",
+                          "ballerina",
+                          "regally",
+                          "clergy",
+                          "largely",
+                          "leading"
+                        ],
+          "expected": ["gallery", "regally", "largely"]
+        },
+        {
+          "description": "does not detect identical words",
+          "property": "anagrams",
+          "subject": "corn",
+          "candidates": ["corn", "dark", "Corn", "rank", "CORN", "cron", "park"],
+          "expected": ["cron"]
+        },
+        {
+          "description": "does not detect non-anagrams with identical checksum",
+          "property": "anagrams",
+          "subject": "mass",
+          "candidates": ["last"],
+          "expected": []
+        },
+        {
+          "description": "detects anagrams case-insensitively",
+          "property": "anagrams",
+          "subject": "Orchestra",
+          "candidates": ["cashregister", "Carthorse", "radishes"],
+          "expected": ["Carthorse"]
+        },
+        {
+          "description": "detects anagrams using case-insensitive subject",
+          "property": "anagrams",
+          "subject": "Orchestra",
+          "candidates": ["cashregister", "carthorse", "radishes"],
+          "expected": ["carthorse"]
+        },
+        {
+          "description": "detects anagrams using case-insensitive possible matches",
+          "property": "anagrams",
+          "subject": "orchestra",
+          "candidates": ["cashregister", "Carthorse", "radishes"],
+          "expected": ["Carthorse"]
+        },
+        {
+          "description": "does not detect a word as its own anagram",
+          "property": "anagrams",
+          "subject": "banana",
+          "candidates": ["Banana"],
+          "expected": []
+        },
+        {
+          "description": "does not detect a anagram if the original word is repeated",
+          "property": "anagrams",
+          "subject": "go",
+          "candidates": ["go Go GO"],
+          "expected": []
+        },
+        {
+          "description": "anagrams must use all letters exactly once",
+          "property": "anagrams",
+          "subject": "tapper",
+          "candidates": ["patter"],
+          "expected": []
+        },
+        {
+          "description": "capital word is not own anagram",
+          "property": "anagrams",
+          "subject": "BANANA",
+          "candidates": ["Banana"],
+          "expected": []
+        }
+      ]
+    }
+  ｣
+}