trackler 2.0.8.20 → 2.0.8.21

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

@@ -0,0 +1,163 @@
+#!/usr/bin/env perl6
+use v6;
+use Test;
+use lib $?FILE.IO.dirname;
+
+my $exercise = 'AllYourBase';
+my $version = v1;
+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). "
+    ~ "Test is $($version.gist).\n";
+  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>);
+
+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>;
+}
+
+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
+      } ]
+    }
+  ｣
+}

data/tracks/perl6/exercises/bob/Bob.pm6

@@ -0,0 +1,13 @@
+#`[
+  Declare class 'Bob' with version and unit-scope the class
+  i.e. everything in this file is part of 'Bob'.
+]
+unit class Bob:ver<1>;
+
+method hey ($msg) {
+  #`[
+    Remove the comments and write some code here to pass the test suite.
+    You can experiment with the code outside of this block,
+    but no changes are needed for the test suite to pass.
+  ]
+}

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

@@ -1,10 +1,10 @@
-class Bob is export {
-    method hey ($input) {
-        given $input {
-            when /^\s*$/                            { 'Fine. Be that way!' }
-            when /<:Upper>/ and $input.uc eq $input { 'Whoa, chill out!'   }
-            when /'?'$/                             { 'Sure.'              }
-            default                                 { 'Whatever.'          }
-        }
-    }
+unit class Bob:ver<1>;
+
+method hey ($msg) {
+  given $msg.trim {
+    when !*                        { 'Fine. Be that way!' }
+    when /<:Upper>/ and $_.uc eq * { 'Whoa, chill out!'   }
+    when /'?'$/                    { 'Sure.'              }
+    default                        { 'Whatever.'          }
+  }
 }

data/tracks/perl6/exercises/bob/bob.t

@@ -1,38 +1,205 @@
 #!/usr/bin/env perl6
 use v6;
 use Test;
-use lib IO::Path.new($?FILE).parent.path;
-
-plan 21;
-my $module = %*ENV<EXERCISM> ?? 'Example' !! 'Bob';
-use-ok $module;
-require ::($module) <Bob>;
-
-ok Bob.can('hey'), 'Class Bob has hey() method';
-
-my @cases =
-    # input                                           expected output        title
-    ['Tom-ay-to, tom-aaaah-to.',                       'Whatever.',          'stating something'],
-    ['WATCH OUT!',                                     'Whoa, chill out!',   'shouting'],
-    ['Does this cryogenic chamber make me look fat?',  'Sure.',              'question'],
-    ['You are, what, like 15?',                        'Sure.',              'numeric question'],
-    ["Let's go make out behind the gym!",              'Whatever.',          'talking forcefully'],
-    ["It's OK if you don't want to go to the DMV.",    'Whatever.',          'using acronyms in regular speech'],
-    ['WHAT THE HELL WERE YOU THINKING?',               'Whoa, chill out!',   'forceful questions'],
-    ['1, 2, 3 GO!',                                    'Whoa, chill out!',   'shouting numbers'],
-    ['1, 2, 3',                                        'Whatever.',          'only numbers'],
-    ['4?',                                             'Sure.',              'question with only numbers'],
-    ['ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!',  'Whoa, chill out!',   'shouting with special characters'],
-    ["ÜMLÄÜTS!",                                       'Whoa, chill out!',   'shouting with umlauts'],
-    ["\xdcML\xc4\xdcTS!",                              'Whoa, chill out!',   'shouting with umlauts'],
-    ["ÜMLäÜTS!",                                       'Whatever.',          'speaking calmly with umlauts'],
-    ['I HATE YOU',                                     'Whoa, chill out!',   'shouting with no exclamation mark'],
-    ['Ending with ? means a question.',                'Whatever.',          'statement containing question mark'],
-    ["Wait! Hang on. Are you going to be OK?",         'Sure.',              'prattling on'],
-    ['',                                               'Fine. Be that way!', 'silence'],
-    ['    ',                                           'Fine. Be that way!', 'prolonged silence'],
-;
-
-for @cases -> ( $string, $expected, $msg ) {
-    is Bob.hey($string), $expected, $msg;
+use lib my $dir = $?FILE.IO.dirname; # Look for the module inside the same directory as this test file.
+use JSON::Tiny;
+
+my $exercise = 'Bob'; # The name of this exercise.
+my $version = v1; # The version we will be matching against the exercise.
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise; # %*ENV<EXERCISM> is for tests not directly for the exercise, don't worry about these :)
+plan 28; # This is how many tests we expect to run.
+
+# Check that the module can be use-d.
+use-ok $module or bail-out;
+require ::($module);
+
+# If the exercise is updated, we want to make sure other people testing
+# your code don't think you've made a mistake if things have changed!
+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>;
+}
+
+# Check that the Class 'Bob' can use all of the methods
+# needed in the tests (only 'hey' for this one).
+subtest 'Class method(s)', {
+  plan 1;
+  ok ::($exercise).can($_), $_ for <hey>;
+}
+
+# Go through all of the cases (hiding at the bottom of this file)
+# and check that Bob gives us the correct response for each one.
+is ::($exercise).?hey(.<input>), |.<expected description> for @(my $c-data.<cases>);
+
+# Ignore this for your exercise! Tells Exercism folks when exercise cases become out of date.
+if %*ENV<EXERCISM> && (my $c-data-file = "$dir/../../x-common/exercises/{$dir.IO.basename}/canonical-data.json".IO.resolve) ~~ :f {
+  is $c-data, from-json($c-data-file.slurp), 'canonical-data'
+} else { skip }
+
+# There are no more tests after this :)
+done-testing;
+
+# 'INIT' is a phaser, it makes sure that the test data is available before everything else
+# starts running (otherwise we'd have to shove all of this into the middle of the file!)
+INIT {
+  $c-data := from-json ｢
+    {
+      "exercise": "bob",
+      "version": "1.0.0",
+      "cases": [
+        {
+          "description": "stating something",
+          "property": "response",
+          "input": "Tom-ay-to, tom-aaaah-to.",
+          "expected": "Whatever."
+        },
+        {
+          "description": "shouting",
+          "property": "response",
+          "input": "WATCH OUT!",
+          "expected": "Whoa, chill out!"
+        },
+        {
+          "description": "shouting gibberish",
+          "property": "response",
+          "input": "FCECDFCAAB",
+          "expected": "Whoa, chill out!"
+        },
+        {
+          "description": "asking a question",
+          "property": "response",
+          "input": "Does this cryogenic chamber make me look fat?",
+          "expected": "Sure."
+        },
+        {
+          "description": "asking a numeric question",
+          "property": "response",
+          "input": "You are, what, like 15?",
+          "expected": "Sure."
+        },
+        {
+          "description": "asking gibberish",
+          "property": "response",
+          "input": "fffbbcbeab?",
+          "expected": "Sure."
+        },
+        {
+          "description": "talking forcefully",
+          "property": "response",
+          "input": "Let's go make out behind the gym!",
+          "expected": "Whatever."
+        },
+        {
+          "description": "using acronyms in regular speech",
+          "property": "response",
+          "input": "It's OK if you don't want to go to the DMV.",
+          "expected": "Whatever."
+        },
+        {
+          "description": "forceful question",
+          "property": "response",
+          "input": "WHAT THE HELL WERE YOU THINKING?",
+          "expected": "Whoa, chill out!"
+        },
+        {
+          "description": "shouting numbers",
+          "property": "response",
+          "input": "1, 2, 3 GO!",
+          "expected": "Whoa, chill out!"
+        },
+        {
+          "description": "only numbers",
+          "property": "response",
+          "input": "1, 2, 3",
+          "expected": "Whatever."
+        },
+        {
+          "description": "question with only numbers",
+          "property": "response",
+          "input": "4?",
+          "expected": "Sure."
+        },
+        {
+          "description": "shouting with special characters",
+          "property": "response",
+          "input": "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!",
+          "expected": "Whoa, chill out!"
+        },
+        {
+          "description": "shouting with no exclamation mark",
+          "property": "response",
+          "input": "I HATE YOU",
+          "expected": "Whoa, chill out!"
+        },
+        {
+          "description": "statement containing question mark",
+          "property": "response",
+          "input": "Ending with ? means a question.",
+          "expected": "Whatever."
+        },
+        {
+          "description": "non-letters with question",
+          "property": "response",
+          "input": ":) ?",
+          "expected": "Sure."
+        },
+        {
+          "description": "prattling on",
+          "property": "response",
+          "input": "Wait! Hang on. Are you going to be OK?",
+          "expected": "Sure."
+        },
+        {
+          "description": "silence",
+          "property": "response",
+          "input": "",
+          "expected": "Fine. Be that way!"
+        },
+        {
+          "description": "prolonged silence",
+          "property": "response",
+          "input": "          ",
+          "expected": "Fine. Be that way!"
+        },
+        {
+          "description": "alternate silence",
+          "property": "response",
+          "input": "\t\t\t\t\t\t\t\t\t\t",
+          "expected": "Fine. Be that way!"
+        },
+        {
+          "description": "multiple line question",
+          "property": "response",
+          "input": "\nDoes this cryogenic chamber make me look fat?\nno",
+          "expected": "Whatever."
+        },
+        {
+          "description": "starting with whitespace",
+          "property": "response",
+          "input": "         hmmmmmmm...",
+          "expected": "Whatever."
+        },
+        {
+          "description": "ending with whitespace",
+          "property": "response",
+          "input": "Okay if like my  spacebar  quite a bit?   ",
+          "expected": "Sure."
+        },
+        {
+          "description": "other whitespace",
+          "property": "response",
+          "input": "\n\r \t",
+          "expected": "Fine. Be that way!"
+        },
+        {
+          "description": "non-question ending with whitespace",
+          "property": "response",
+          "input": "This is a statement ending with whitespace      ",
+          "expected": "Whatever."
+        }
+      ]
+    }
+  ｣
 }

data/tracks/perl6/exercises/grade-school/Example.pm

@@ -1,17 +1,18 @@
-use v6;
+unit module GradeSchool:ver<1>;
 
-unit class GradeSchool::Roster is export;
-has %!roster;
+class Roster is export {
+  has %!roster;
 
-method add-student (Str:D :$name!, Int:D :$grade!) {
-  %!roster.append($grade, $name);
-}
+  method add-student (Str:D :$name!, Int:D :$grade!) {
+    %!roster.append($grade, $name);
+  }
 
-method list-grade (Int:D $grade --> Seq:D) {
-  %!roster{$grade}.sort;
-}
+  method list-grade (Int:D $grade --> Seq:D) {
+    %!roster{$grade}.sort;
+  }
 
-method list-all {
-  my @list.append("Grade $_", %!roster{$_}.sort) for %!roster.keys.sort;
-  return @list;
+  method list-all {
+    my @list.append("Grade $_", %!roster{$_}.sort) for %!roster.keys.sort;
+    return @list;
+  }
 }

data/tracks/perl6/exercises/grade-school/GradeSchool.pm6

@@ -0,0 +1,4 @@
+unit module GradeSchool:ver<1>;
+
+class Roster is export {
+}

data/tracks/perl6/exercises/grade-school/grade-school.t

@@ -1,32 +1,51 @@
 #!/usr/bin/env perl6
 use v6;
 use Test;
-use lib IO::Path.new($?FILE).parent.path;
+use lib $?FILE.IO.dirname;
 
-plan 10;
-my $module = %*ENV<EXERCISM> ?? 'Example' !! 'GradeSchool';
-use-ok $module;
-require ::($module) <Roster>;
+my $exercise = 'GradeSchool';
+my $version = v1;
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
+plan 11;
 
-subtest 'Can use all methods', {
-  plan 3;
-  ok Roster.can($_), $_ for <add-student list-grade list-all>;
-} or fail 'Missing method(s)';
+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>;
+}
+
+my @classes;
+BEGIN { @classes = <Roster> };
+subtest 'Class(es)', {
+  plan 1;
+  eval-lives-ok "use $module; ::('$_').new or die 'Could not use .new method on class $_.\'", $_ for @classes;
+} or bail-out 'All classes must be defined and exported.';
+require ::($module) @classes.eager;
+
+for @classes -> $class {
+  subtest "$class class method(s)", {
+    plan 3;
+    ok ::($class).can($_), $_ for <add-student list-grade list-all>;
+  }
+}
 
 my $roster = Roster.new;
 
-ok $roster.add-student(:name('Jim'), :2grade), 'Add Jim to grade 2';
-is $roster.list-grade(2), <Jim>, 'List grade 2';
-ok $roster.add-student(:name('Zoe'), :2grade), 'Add Zoe to grade 2';
-ok $roster.add-student(:name('Barb'), :1grade), 'Add Barb to grade 1';
-is $roster.list-grade(2), <Jim Zoe>, 'List grade 2';
-is $roster.list-grade(1), <Barb>, 'List grade 1';
+ok $roster.?add-student(:name('Jim'), :2grade), 'Add Jim to grade 2';
+is $roster.?list-grade(2), <Jim>, 'List grade 2';
+ok $roster.?add-student(:name('Zoe'), :2grade), 'Add Zoe to grade 2';
+ok $roster.?add-student(:name('Barb'), :1grade), 'Add Barb to grade 1';
+is $roster.?list-grade(2), <Jim Zoe>, 'List grade 2';
+is $roster.?list-grade(1), <Barb>, 'List grade 1';
 
 subtest 'Additional students', {
   plan 6;
-  ok $roster.add-student(:name($_), :1grade), "Add $_ to grade 1" for <Charlie Anna>;
-  ok $roster.add-student(:name('Alex'), :2grade), 'Add Alex to grade 2';
-  ok $roster.add-student(:name($_), :3grade), "Add $_ to grade 3" for <Tom Dick Harry>;
+  ok $roster.?add-student(:name($_), :1grade), "Add $_ to grade 1" for <Charlie Anna>;
+  ok $roster.?add-student(:name('Alex'), :2grade), 'Add Alex to grade 2';
+  ok $roster.?add-student(:name($_), :3grade), "Add $_ to grade 3" for <Tom Dick Harry>;
 }
 
-is $roster.list-all, ('Grade 1', <Anna Barb Charlie>, 'Grade 2', <Alex Jim Zoe>, 'Grade 3', <Dick Harry Tom>), 'List all';
+is $roster.?list-all, ('Grade 1', <Anna Barb Charlie>, 'Grade 2', <Alex Jim Zoe>, 'Grade 3', <Dick Harry Tom>), 'List all';

data/tracks/perl6/exercises/hello-world/Example.pm

@@ -1,5 +1,5 @@
-unit module HelloWorld:ver<1>;
+unit module HelloWorld:ver<2>;
 
-sub hello (Str $name? --> Str:D) is export {
-  'Hello, ' ~ ($name ?? $name !! 'World') ~ '!'
+sub hello is export {
+  'Hello, World!'
 }

data/tracks/perl6/exercises/hello-world/HelloWorld.pm6

@@ -7,9 +7,9 @@
   and test suite line up. If the test is updated, it will indicate
   to others who test your code that some tests may no longer pass.
 )
-unit module HelloWorld:ver<1>;
+unit module HelloWorld:ver<2>;
 
-sub hello ($name?) is export {
+sub hello is export {
   # Write your solution to pass the test suite here.
   # Be sure to remove all stock comments once you are done!
 }

data/tracks/perl6/exercises/hello-world/hello-world.t

@@ -1,15 +1,20 @@
 #!/usr/bin/env perl6
 use v6;
 use Test;
-use lib IO::Path.new($?FILE).parent.path;
+use lib my $dir = $?FILE.IO.dirname; # Look for the module inside the same directory as this test file.
+use JSON::Tiny;
 
-my $exercise = 'HelloWorld';
-my $version = v1;
-my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
-plan 6;
+my $exercise = 'HelloWorld'; # The name of this exercise.
+my $version = v2; # The version we will be matching against the exercise.
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise; # %*ENV<EXERCISM> is for tests not directly for the exercise, don't worry about these :)
+plan 4; # This is how many tests we expect to run.
 
+# Check that the module can be use-d.
 use-ok $module or bail-out;
 require ::($module);
+
+# If the exercise is updated, we want to make sure other people testing
+# your code don't think you've made a mistake if things have changed!
 if ::($exercise).^ver !~~ $version {
   warn "\nExercise version mismatch. Further tests may fail!"
     ~ "\n$exercise is $(::($exercise).^ver.gist). "
@@ -17,6 +22,8 @@ if ::($exercise).^ver !~~ $version {
   bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
 }
 
+# Check that the Module 'HelloWorld' can use all of the subroutines
+# needed in the tests (only '&hello' for this one).
 my @subs;
 BEGIN { @subs = <&hello> };
 subtest 'Subroutine(s)', {
@@ -25,8 +32,32 @@ subtest 'Subroutine(s)', {
 } or bail-out 'All subroutines must be defined and exported.';
 require ::($module) @subs.eager;
 
-is hello, 'Hello, World!', 'No argument';
-is ''.&hello, 'Hello, World!', 'Empty string';
-todo 'optional test', 2 unless %*ENV<EXERCISM>;
-is 'Camelia'.&hello, 'Hello, Camelia!', 'Camelia';
-is '楽土'.&hello, 'Hello, 楽土!', 'Rakudo';
+# Go through the cases (hiding at the bottom of this file)
+# and check that &hello gives us the correct response.
+is hello, |.<expected description> for @(my $c-data.<cases>);
+
+# Ignore this for your exercise! Tells Exercism folks when exercise cases become out of date.
+if %*ENV<EXERCISM> && (my $c-data-file = "$dir/../../x-common/exercises/{$dir.IO.basename}/canonical-data.json".IO.resolve) ~~ :f {
+  is $c-data, from-json($c-data-file.slurp), 'canonical-data'
+} else { skip }
+
+# There are no more tests after this :)
+done-testing;
+
+# 'INIT' is a phaser, it makes sure that the test data is available before everything else
+# starts running (otherwise we'd have to shove the test data into the middle of the file!)
+INIT {
+  $c-data := from-json ｢
+    {
+      "exercise": "hello-world",
+      "version": "1.0.0",
+      "cases": [
+        {
+          "description": "Say Hi!",
+          "property": "hello",
+          "expected": "Hello, World!"
+        }
+      ]
+    }
+  ｣
+}