trackler 2.0.8.33 → 2.0.8.34

data/tracks/perl6/.travis.yml

@@ -1,6 +1,9 @@
 ---
 sudo: false
 language: perl6
+perl6:
+  - latest
+  - '2017.01' # Latest Rakudo Star
 install:
   - rakudobrew build zef
   - zef install JSON::Tiny

data/tracks/python/exercises/bob/bob_test.py

@@ -1,123 +1,99 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import unicode_literals
 import unittest
 
 import bob
 
 
-class BobTests(unittest.TestCase):
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
 
+class BobTests(unittest.TestCase):
     def test_stating_something(self):
-        self.assertEqual(
-            'Whatever.',
-            bob.hey('Tom-ay-to, tom-aaaah-to.')
-        )
+        self.assertEqual(bob.hey("Tom-ay-to, tom-aaaah-to."), "Whatever.")
 
     def test_shouting(self):
-        self.assertEqual(
-            'Whoa, chill out!',
-            bob.hey('WATCH OUT!')
-        )
+        self.assertEqual(bob.hey("WATCH OUT!"), "Whoa, chill out!")
+
+    def test_shouting_gibberish(self):
+        self.assertEqual(bob.hey("FCECDFCAAB"), "Whoa, chill out!")
 
     def test_asking_a_question(self):
         self.assertEqual(
-            'Sure.',
-            bob.hey('Does this cryogenic chamber make me look fat?')
-        )
+            bob.hey("Does this cryogenic chamber make me look fat?"), "Sure.")
 
     def test_asking_a_numeric_question(self):
-        self.assertEqual(
-            'Sure.',
-            bob.hey('You are, what, like 15?')
-        )
+        self.assertEqual(bob.hey("You are, what, like 15?"), "Sure.")
+
+    def test_asking_gibberish(self):
+        self.assertEqual(bob.hey("fffbbcbeab?"), "Sure.")
 
     def test_talking_forcefully(self):
         self.assertEqual(
-            'Whatever.',
-            bob.hey("Let's go make out behind the gym!")
-        )
+            bob.hey("Let's go make out behind the gym!"), "Whatever.")
 
     def test_using_acronyms_in_regular_speech(self):
         self.assertEqual(
-            'Whatever.', bob.hey("It's OK if you don't want to go to the DMV.")
-        )
+            bob.hey("It's OK if you don't want to go to the DMV."),
+            "Whatever.")
 
-    def test_forceful_questions(self):
+    def test_forceful_question(self):
         self.assertEqual(
-            'Whoa, chill out!', bob.hey('WHAT THE HELL WERE YOU THINKING?')
-        )
+            bob.hey("WHAT THE HELL WERE YOU THINKING?"), "Whoa, chill out!")
 
     def test_shouting_numbers(self):
-        self.assertEqual(
-            'Whoa, chill out!', bob.hey('1, 2, 3 GO!')
-        )
+        self.assertEqual(bob.hey("1, 2, 3 GO!"), "Whoa, chill out!")
 
     def test_only_numbers(self):
-        self.assertEqual(
-            'Whatever.', bob.hey('1, 2, 3')
-        )
+        self.assertEqual(bob.hey("1, 2, 3"), "Whatever.")
 
     def test_question_with_only_numbers(self):
-        self.assertEqual(
-            'Sure.', bob.hey('4?')
-        )
+        self.assertEqual(bob.hey("4?"), "Sure.")
 
     def test_shouting_with_special_characters(self):
         self.assertEqual(
-            'Whoa, chill out!',
-            bob.hey('ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!')
-        )
-
-    def test_shouting_with_umlauts(self):
-        self.assertEqual(
-            'Whoa, chill out!', bob.hey('ÜMLÄÜTS!')
-        )
-
-    def test_calmly_speaking_with_umlauts(self):
-        self.assertEqual(
-            'Whatever.', bob.hey('ÜMLäÜTS!')
-        )
+            bob.hey("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"),
+            "Whoa, chill out!")
 
     def test_shouting_with_no_exclamation_mark(self):
-        self.assertEqual(
-            'Whoa, chill out!', bob.hey('I HATE YOU')
-        )
+        self.assertEqual(bob.hey("I HATE YOU"), "Whoa, chill out!")
 
     def test_statement_containing_question_mark(self):
         self.assertEqual(
-            'Whatever.', bob.hey('Ending with ? means a question.')
-        )
+            bob.hey("Ending with ? means a question."), "Whatever.")
+
+    def test_non_letters_with_question(self):
+        self.assertEqual(bob.hey(":) ?"), "Sure.")
 
     def test_prattling_on(self):
         self.assertEqual(
-            'Sure.', bob.hey("Wait! Hang on. Are you going to be OK?")
-        )
+            bob.hey("Wait! Hang on. Are you going to be OK?"), "Sure.")
 
     def test_silence(self):
-        self.assertEqual(
-            'Fine. Be that way!', bob.hey('')
-        )
+        self.assertEqual(bob.hey(""), "Fine. Be that way!")
 
     def test_prolonged_silence(self):
-        self.assertEqual(
-            'Fine. Be that way!', bob.hey('    \t')
-        )
+        self.assertEqual(bob.hey("          "), "Fine. Be that way!")
+
+    def test_alternate_silence(self):
+        self.assertEqual(bob.hey("\t\t\t\t\t\t\t\t\t\t"), "Fine. Be that way!")
 
-    def test_starts_with_whitespace(self):
+    def test_multiple_line_question(self):
         self.assertEqual(
-            'Whatever.', bob.hey('         hmmmmmmm...')
-        )
+            bob.hey("\nDoes this cryogenic chamber make me look fat?\nno"),
+            "Whatever.")
 
-    def test_ends_with_whitespace(self):
+    def test_starting_with_whitespace(self):
+        self.assertEqual(bob.hey("         hmmmmmmm..."), "Whatever.")
+
+    def test_ending_with_whitespace(self):
         self.assertEqual(
-            'Sure.', bob.hey('What if we end with whitespace?   ')
-        )
+            bob.hey("Okay if like my  spacebar  quite a bit?   "), "Sure.")
+
+    def test_other_whitespace(self):
+        self.assertEqual(bob.hey("\n\r \t"), "Fine. Be that way!")
 
-    def test_non_question_ends_with_whitespace(self):
+    def test_non_question_ending_with_whitespace(self):
         self.assertEqual(
-            'Whatever.', bob.hey('This is a statement with trailing whitespace   ')
-        )
+            bob.hey("This is a statement ending with whitespace      "),
+            "Whatever.")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/leap/leap_test.py

@@ -3,21 +3,20 @@ import unittest
 from leap import is_leap_year
 
 
-class YearTest(unittest.TestCase):
-    def test_leap_year(self):
-        self.assertIs(is_leap_year(1996), True)
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
 
-    def test_non_leap_year(self):
-        self.assertIs(is_leap_year(1997), False)
+class YearTest(unittest.TestCase):
+    def test_year_not_divisible_by_4(self):
+        self.assertFalse(is_leap_year(2015))
 
-    def test_non_leap_even_year(self):
-        self.assertIs(is_leap_year(1998), False)
+    def test_year_divisible_by_4_not_divisible_by_100(self):
+        self.assertTrue(is_leap_year(2016))
 
-    def test_century(self):
-        self.assertIs(is_leap_year(1900), False)
+    def test_year_divisible_by_100_not_divisible_by_400(self):
+        self.assertFalse(is_leap_year(2100))
 
-    def test_exceptional_century(self):
-        self.assertIs(is_leap_year(2400), True)
+    def test_year_divisible_by_400(self):
+        self.assertTrue(is_leap_year(2000))
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/pangram/pangram_test.py

@@ -1,45 +1,45 @@
-# -*- coding: utf-8 -*-
-
 import unittest
 
 from pangram import is_pangram
 
 
-class PangramTests(unittest.TestCase):
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
 
-    def test_empty_string(self):
+class PangramTests(unittest.TestCase):
+    def test_sentence_empty(self):
         self.assertFalse(is_pangram(''))
 
-    def test_valid_pangram(self):
+    def test_pangram_with_only_lower_case(self):
         self.assertTrue(
             is_pangram('the quick brown fox jumps over the lazy dog'))
 
-    def test_missing_x(self):
-        self.assertFalse(is_pangram('a quick movement of the enemy will '
-                                    'jeopardize five gunboats'))
+    def test_missing_character_x(self):
+        self.assertFalse(
+            is_pangram('a quick movement of the enemy will '
+                       'jeopardize five gunboats'))
 
-    def test_another_missing_character(self):
+    def test_another_missing_character_x(self):
         self.assertFalse(
             is_pangram('the quick brown fish jumps over the lazy dog'))
 
     def test_pangram_with_underscores(self):
         self.assertTrue(
-            is_pangram("the_quick_brown_fox_jumps_over_the_lazy_dog"))
+            is_pangram('the_quick_brown_fox_jumps_over_the_lazy_dog'))
 
     def test_pangram_with_numbers(self):
         self.assertTrue(
-            is_pangram("the 1 quick brown fox jumps over the 2 lazy dogs"))
+            is_pangram('the 1 quick brown fox jumps over the 2 lazy dogs'))
 
     def test_missing_letters_replaced_by_numbers(self):
         self.assertFalse(
-            is_pangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog"))
+            is_pangram('7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog'))
 
-    def test_mixedcase_and_punctuation(self):
+    def test_pangram_with_mixedcase_and_punctuation(self):
         self.assertTrue(is_pangram('"Five quacking Zephyrs jolt my wax bed."'))
 
-    def test_unchecked_german_umlaute(self):
-        self.assertTrue(is_pangram('Victor jagt zwölf Boxkämpfer quer über den'
-                                   ' großen Sylter Deich.'))
+    def test_upper_and_lower_case_versions_of_the_same_character(self):
+        self.assertFalse(
+            is_pangram('the quick brown fox jumped over the lazy FOX'))
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/prime-factors/prime_factors_test.py

@@ -3,38 +3,28 @@ import unittest
 from prime_factors import prime_factors
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class PrimeFactorsTest(unittest.TestCase):
-    def test_1(self):
+    def test_no_factors(self):
         self.assertEqual(prime_factors(1), [])
 
-    def test_2(self):
+    def test_prime_number(self):
         self.assertEqual(prime_factors(2), [2])
 
-    def test_3(self):
-        self.assertEqual(prime_factors(3), [3])
-
-    def test_4(self):
-        self.assertEqual(prime_factors(4), [2, 2])
-
-    def test_6(self):
-        self.assertEqual(prime_factors(6), [2, 3])
-
-    def test_8(self):
-        self.assertEqual(prime_factors(8), [2, 2, 2])
-
-    def test_9(self):
+    def test_square_of_a_prime(self):
         self.assertEqual(prime_factors(9), [3, 3])
 
-    def test_27(self):
-        self.assertEqual(prime_factors(27), [3, 3, 3])
+    def test_cube_of_a_prime(self):
+        self.assertEqual(prime_factors(8), [2, 2, 2])
 
-    def test_625(self):
-        self.assertEqual(prime_factors(625), [5, 5, 5, 5])
+    def test_product_of_primes_and_non_primes(self):
+        self.assertEqual(prime_factors(12), [2, 2, 3])
 
-    def test_901255(self):
+    def test_product_of_primes(self):
         self.assertEqual(prime_factors(901255), [5, 17, 23, 461])
 
-    def test_93819012551(self):
+    def test_factors_include_a_large_prime(self):
         self.assertEqual(prime_factors(93819012551), [11, 9539, 894119])
 
 

data/tracks/python/exercises/sieve/sieve_test.py

@@ -3,31 +3,39 @@ import unittest
 from sieve import sieve
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class SieveTest(unittest.TestCase):
-    def test_a_few_primes(self):
-        expected = [2, 3, 5, 7]
-        self.assertEqual(expected, sieve(10))
-
-    def test_prime_limit(self):
-        expected = [2, 3, 5, 7]
-        self.assertEqual(expected, sieve(7))
-
-    def test_primes(self):
-        expected = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
-                    53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109,
-                    113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179,
-                    181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241,
-                    251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
-                    317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389,
-                    397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461,
-                    463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547,
-                    557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617,
-                    619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691,
-                    701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773,
-                    787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859,
-                    863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947,
-                    953, 967, 971, 977, 983, 991, 997]
-        self.assertEqual(expected, sieve(1000))
+    def test_no_primes_under_two(self):
+        self.assertEqual(sieve(1), [])
+
+    def test_find_first_prime(self):
+        self.assertEqual(sieve(2), [2])
+
+    def test_find_primes_up_to_10(self):
+        self.assertEqual(sieve(10), [2, 3, 5, 7])
+
+    def test_limit_is_prime(self):
+        self.assertEqual(sieve(13), [2, 3, 5, 7, 11, 13])
+
+    def test_find_primes_up_to_1000(self):
+        self.assertEqual(
+            sieve(1000), [
+                2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
+                61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
+                131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191,
+                193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257,
+                263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331,
+                337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401,
+                409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467,
+                479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
+                569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631,
+                641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709,
+                719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797,
+                809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877,
+                881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967,
+                971, 977, 983, 991, 997
+            ])
 
 
 if __name__ == '__main__':

data/tracks/swift/.gitignore

@@ -20,3 +20,6 @@ DerivedData
 *.ipa
 *.xcuserstate
 .DS_Store
+
+#Idea IDE
+.idea

data/tracks/swift/.swiftlint.yml

@@ -3,11 +3,13 @@ identifier_name:
         warning: 1
         error: 0
 
+large_tuple:
+    warning: 5
+    error: 6
+
 colon:
   apply_to_dictionaries: false
 
-force_try: warning
-
 opt_in_rules:
   - vertical_whitespace
   - closure_spacing

data/tracks/swift/exercises/kindergarten-garden/Sources/KindergartenGardenExample.swift

@@ -1,10 +1,10 @@
 import Foundation
 
 enum Plant: String {
-    case Grass = "G"
-    case Clover = "C"
-    case Radishes = "R"
-    case Violets = "V"
+    case grass = "G"
+    case clover = "C"
+    case radishes = "R"
+    case violets = "V"
 }
 
 struct Garden {

data/tracks/swift/exercises/kindergarten-garden/Tests/KindergartenGardenTests/KindergartenGardenTests.swift

@@ -10,100 +10,100 @@ class KindergartenGardenTests: XCTestCase {
 
     func testAlicesGarden() {
         let garden = Garden("RC\nGG")
-        XCTAssertEqual([.Radishes, .Clover, .Grass, .Grass], garden.plantsForChild("Alice"))
+        XCTAssertEqual([.radishes, .clover, .grass, .grass], garden.plantsForChild("Alice"))
     }
 
     func testDifferentGardenForAlice() {
         let garden = Garden("VC\nRC")
-        XCTAssertEqual([.Violets, .Clover, .Radishes, .Clover], garden.plantsForChild("Alice"))
+        XCTAssertEqual([.violets, .clover, .radishes, .clover], garden.plantsForChild("Alice"))
     }
 
     func testBobsGarden() {
         let garden = Garden("VVCG\nVVRC")
-        XCTAssertEqual([.Clover, .Grass, .Radishes, .Clover], garden.plantsForChild("Bob"))
+        XCTAssertEqual([.clover, .grass, .radishes, .clover], garden.plantsForChild("Bob"))
     }
 
     func testBobAndCharliesGardens() {
         let garden = Garden("VVCCGG\nVVCCGG")
-        XCTAssertEqual([.Clover, .Clover, .Clover, .Clover], garden.plantsForChild("Bob"))
-        XCTAssertEqual([.Grass, .Grass, .Grass, .Grass], garden.plantsForChild("Charlie"))
+        XCTAssertEqual([.clover, .clover, .clover, .clover], garden.plantsForChild("Bob"))
+        XCTAssertEqual([.grass, .grass, .grass, .grass], garden.plantsForChild("Charlie"))
     }
 
     // MARK: - Test full garden
 
     func testAlice() {
-        XCTAssertEqual([.Violets, .Radishes, .Violets, .Radishes], fullGarden.plantsForChild("Alice"))
+        XCTAssertEqual([.violets, .radishes, .violets, .radishes], fullGarden.plantsForChild("Alice"))
     }
 
     func testBob() {
-        XCTAssertEqual([.Clover, .Grass, .Clover, .Clover], fullGarden.plantsForChild("Bob"))
+        XCTAssertEqual([.clover, .grass, .clover, .clover], fullGarden.plantsForChild("Bob"))
     }
 
     func testCharlie() {
-        XCTAssertEqual([.Violets, .Violets, .Clover, .Grass], fullGarden.plantsForChild("Charlie"))
+        XCTAssertEqual([.violets, .violets, .clover, .grass], fullGarden.plantsForChild("Charlie"))
     }
 
     func testDavid() {
-        XCTAssertEqual([.Radishes, .Violets, .Clover, .Radishes], fullGarden.plantsForChild("David"))
+        XCTAssertEqual([.radishes, .violets, .clover, .radishes], fullGarden.plantsForChild("David"))
     }
 
     func testEve() {
-        XCTAssertEqual([.Clover, .Grass, .Radishes, .Grass], fullGarden.plantsForChild("Eve"))
+        XCTAssertEqual([.clover, .grass, .radishes, .grass], fullGarden.plantsForChild("Eve"))
     }
 
     func testFred() {
-        XCTAssertEqual([.Grass, .Clover, .Violets, .Clover], fullGarden.plantsForChild("Fred"))
+        XCTAssertEqual([.grass, .clover, .violets, .clover], fullGarden.plantsForChild("Fred"))
     }
 
     func testGinny() {
-        XCTAssertEqual([.Clover, .Grass, .Grass, .Clover], fullGarden.plantsForChild("Ginny"))
+        XCTAssertEqual([.clover, .grass, .grass, .clover], fullGarden.plantsForChild("Ginny"))
     }
 
     func testHarriet() {
-        XCTAssertEqual([.Violets, .Radishes, .Radishes, .Violets], fullGarden.plantsForChild("Harriet"))
+        XCTAssertEqual([.violets, .radishes, .radishes, .violets], fullGarden.plantsForChild("Harriet"))
     }
 
     func testIleana() {
-        XCTAssertEqual([.Grass, .Clover, .Violets, .Clover], fullGarden.plantsForChild("Ileana"))
+        XCTAssertEqual([.grass, .clover, .violets, .clover], fullGarden.plantsForChild("Ileana"))
     }
 
     func testJoseph() {
-        XCTAssertEqual([.Violets, .Clover, .Violets, .Grass], fullGarden.plantsForChild("Joseph"))
+        XCTAssertEqual([.violets, .clover, .violets, .grass], fullGarden.plantsForChild("Joseph"))
     }
 
     func testKincaid() {
-        XCTAssertEqual([.Grass, .Clover, .Clover, .Grass], fullGarden.plantsForChild("Kincaid"))
+        XCTAssertEqual([.grass, .clover, .clover, .grass], fullGarden.plantsForChild("Kincaid"))
     }
 
     func testLarry() {
-        XCTAssertEqual([.Grass, .Violets, .Clover, .Violets], fullGarden.plantsForChild("Larry"))
+        XCTAssertEqual([.grass, .violets, .clover, .violets], fullGarden.plantsForChild("Larry"))
     }
 
     // MARK: - Test disordered garden
 
     func testPatricia() {
-        XCTAssertEqual([.Violets, .Clover, .Radishes, .Violets], disorderedGarden.plantsForChild("Patricia"))
+        XCTAssertEqual([.violets, .clover, .radishes, .violets], disorderedGarden.plantsForChild("Patricia"))
     }
 
     func testRoger() {
-        XCTAssertEqual([.Radishes, .Radishes, .Grass, .Clover], disorderedGarden.plantsForChild("Roger"))
+        XCTAssertEqual([.radishes, .radishes, .grass, .clover], disorderedGarden.plantsForChild("Roger"))
     }
 
     func testSamantha() {
-        XCTAssertEqual([.Grass, .Violets, .Clover, .Grass], disorderedGarden.plantsForChild("Samantha"))
+        XCTAssertEqual([.grass, .violets, .clover, .grass], disorderedGarden.plantsForChild("Samantha"))
     }
 
     func testXander() {
-        XCTAssertEqual([.Radishes, .Grass, .Clover, .Violets], disorderedGarden.plantsForChild("Xander"))
+        XCTAssertEqual([.radishes, .grass, .clover, .violets], disorderedGarden.plantsForChild("Xander"))
     }
 
     // MARK: - Test two gardens, different students
 
     func testBobAndCharliePerGarden() {
-        XCTAssertEqual([.Radishes, .Radishes, .Grass, .Clover], garden1.plantsForChild("Bob"))
-        XCTAssertEqual([.Violets, .Clover, .Radishes, .Violets], garden2.plantsForChild("Bob"))
-        XCTAssertEqual([.Grass, .Violets, .Clover, .Grass], garden1.plantsForChild("Charlie"))
-        XCTAssertEqual([.Radishes, .Radishes, .Grass, .Clover], garden2.plantsForChild("Charlie"))
+        XCTAssertEqual([.radishes, .radishes, .grass, .clover], garden1.plantsForChild("Bob"))
+        XCTAssertEqual([.violets, .clover, .radishes, .violets], garden2.plantsForChild("Bob"))
+        XCTAssertEqual([.grass, .violets, .clover, .grass], garden1.plantsForChild("Charlie"))
+        XCTAssertEqual([.radishes, .radishes, .grass, .clover], garden2.plantsForChild("Charlie"))
     }
 
     static var allTests: [(String, (KindergartenGardenTests) -> () throws -> Void)] {