trackler 2.2.1.60 → 2.2.1.61

data/tracks/javascript/exercises/diamond/diamond.spec.js

@@ -4,12 +4,12 @@ describe('Diamond', function () {
   var diamond = new Diamond();
 
   it('test letter A', function () {
-    result = 'A\n';
+    var result = 'A\n';
     expect(diamond.makeDiamond('A')).toEqual(result);
   });
 
   it('test letter C', function () {
-    result = ['  A  ',
+    var result = ['  A  ',
       ' B B ',
       'C   C',
       ' B B ',
@@ -18,7 +18,7 @@ describe('Diamond', function () {
   });
 
   it('test letter E', function () {
-    result = ['    A    ',
+    var result = ['    A    ',
       '   B B   ',
       '  C   C  ',
       ' D     D ',

data/tracks/javascript/exercises/diamond/example.js

@@ -5,8 +5,8 @@ var Diamond = function () {
     for (var i = 0; i <= inputIndex; i++) {
       output += getLine(inputIndex, i);
     }
-    for (var i = inputIndex - 1; i >= 0; i--) {
-      output += getLine(inputIndex, i);
+    for (var j = inputIndex - 1; j >= 0; j--) {
+      output += getLine(inputIndex, j);
     }
     return output;
   };

data/tracks/javascript/exercises/sum-of-multiples/sum-of-multiples.spec.js

@@ -2,38 +2,38 @@ var SumOfMultiples = require('./sum-of-multiples');
 
 describe('SumOfMultiples', function () {
   it('to 1', function () {
-    expect(SumOfMultiples([3, 5]).to(1)).toBe(0);
+    expect(new SumOfMultiples([3, 5]).to(1)).toBe(0);
   });
 
   xit('to 3', function () {
-    expect(SumOfMultiples([3, 5]).to(4)).toBe(3);
+    expect(new SumOfMultiples([3, 5]).to(4)).toBe(3);
   });
 
   xit('to 10', function () {
-    expect(SumOfMultiples([3, 5]).to(10)).toBe(23);
+    expect(new SumOfMultiples([3, 5]).to(10)).toBe(23);
   });
 
   xit('to 100', function () {
-    expect(SumOfMultiples([3, 5]).to(100)).toBe(2318);
+    expect(new SumOfMultiples([3, 5]).to(100)).toBe(2318);
   });
 
   xit('to 1000', function () {
-    expect(SumOfMultiples([3, 5]).to(1000)).toBe(233168);
+    expect(new SumOfMultiples([3, 5]).to(1000)).toBe(233168);
   });
 
   xit('[7, 13, 17] to 20', function () {
-    expect(SumOfMultiples([7, 13, 17]).to(20)).toBe(51);
+    expect(new SumOfMultiples([7, 13, 17]).to(20)).toBe(51);
   });
 
   xit('[4, 6] to 15', function () {
-    expect(SumOfMultiples([4, 6]).to(15)).toBe(30);
+    expect(new SumOfMultiples([4, 6]).to(15)).toBe(30);
   });
 
   xit('[5, 6, 8] to 150', function () {
-    expect(SumOfMultiples([5, 6, 8]).to(150)).toBe(4419);
+    expect(new SumOfMultiples([5, 6, 8]).to(150)).toBe(4419);
   });
 
   xit('[43, 47] to 10000', function () {
-    expect(SumOfMultiples([43, 47]).to(10000)).toBe(2203160);
+    expect(new SumOfMultiples([43, 47]).to(10000)).toBe(2203160);
   });
 });

data/tracks/python/config.json

@@ -1116,17 +1116,39 @@
       ]
     },
     {
-        "uuid": "55c818d6-04a8-2480-de83-9f85fd0d2eafa71935f",
-        "slug": "pov",
-        "core": false,
-        "unlocked_by": null,
-        "difficulty": 9,
-        "topics": [
-            "graphs",
-            "recursion",
-            "searching",
-            "trees"
-        ]
+      "uuid": "4354f631-0cf5-9980-75e7-86d1c3da1f0d3f5e619",
+      "slug": "dominoes",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 7,
+      "topics": [
+        "tuples",
+        "lists"
+      ]
+    },
+    {
+      "uuid": "55c818d6-04a8-2480-de83-9f85fd0d2eafa71935f",
+      "slug": "pov",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 9,
+      "topics": [
+        "graphs",
+        "recursion",
+        "searching",
+        "trees"
+      ]
+    },
+    {
+      "uuid": "21dacf48-0580-4d80-a6d2-257b07ad3cc47b02454",
+      "slug": "react",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 8,
+      "topics": [
+        "events",
+        "reactive_programming"
+      ]
     },
     {
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",

data/tracks/python/exercises/dominoes/README.md

@@ -0,0 +1,28 @@
+# Dominoes
+
+Make a chain of dominoes.
+
+Compute a way to order a given set of dominoes in such a way that they form a
+correct domino chain (the dots on one half of a stone match the dots on the
+neighbouring half of an adjacent stone) and that dots on the halfs of the stones
+which don't have a neighbour (the first and last stone) match each other.
+
+For example given the stones `[2|1]`, `[2|3]` and `[1|3]` you should compute something
+like `[1|2] [2|3] [3|1]` or `[3|2] [2|1] [1|3]` or `[1|3] [3|2] [2|1]` etc, where the first and last numbers are the same.
+
+For stones `[1|2]`, `[4|1]` and `[2|3]` the resulting chain is not valid: `[4|1] [1|2] [2|3]`'s first and last numbers are not the same. 4 != 3
+
+Some test cases may use duplicate stones in a chain solution, assume that multiple Domino sets are being used.
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/dominoes/dominoes.py

@@ -0,0 +1,2 @@
+def chain(dominoes):
+    pass

data/tracks/python/exercises/dominoes/dominoes_test.py

@@ -0,0 +1,114 @@
+import unittest
+
+from dominoes import chain
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v2.0.0
+
+class DominoesTest(unittest.TestCase):
+    def test_empty_input_empty_output(self):
+        input_dominoes = []
+        output_chain = chain(input_dominoes)
+        self.assert_correct_chain(input_dominoes, output_chain)
+
+    def test_singleton_input_singleton_output(self):
+        input_dominoes = [(1, 1)]
+        output_chain = chain(input_dominoes)
+        self.assert_correct_chain(input_dominoes, output_chain)
+
+    def test_singleton_cant_be_chained(self):
+        input_dominoes = [(1, 2)]
+        output_chain = chain(input_dominoes)
+        self.refute_correct_chain(input_dominoes, output_chain)
+
+    def test_three_elements(self):
+        input_dominoes = [(1, 2), (3, 1), (2, 3)]
+        output_chain = chain(input_dominoes)
+        self.assert_correct_chain(input_dominoes, output_chain)
+
+    def test_can_reverse_dominoes(self):
+        input_dominoes = [(1, 2), (1, 3), (2, 3)]
+        output_chain = chain(input_dominoes)
+        self.assert_correct_chain(input_dominoes, output_chain)
+
+    def test_cant_be_chained(self):
+        input_dominoes = [(1, 2), (4, 1), (2, 3)]
+        output_chain = chain(input_dominoes)
+        self.refute_correct_chain(input_dominoes, output_chain)
+
+    def test_disconnected_simple(self):
+        input_dominoes = [(1, 1), (2, 2)]
+        output_chain = chain(input_dominoes)
+        self.refute_correct_chain(input_dominoes, output_chain)
+
+    def test_disconnected_double_loop(self):
+        input_dominoes = [(1, 2), (2, 1), (3, 4), (4, 3)]
+        output_chain = chain(input_dominoes)
+        self.refute_correct_chain(input_dominoes, output_chain)
+
+    def test_disconnected_single_isolated(self):
+        input_dominoes = [(1, 2), (2, 3), (3, 1), (4, 4)]
+        output_chain = chain(input_dominoes)
+        self.refute_correct_chain(input_dominoes, output_chain)
+
+    def test_need_backtrack(self):
+        input_dominoes = [(1, 2), (2, 3), (3, 1), (2, 4), (2, 4)]
+        output_chain = chain(input_dominoes)
+        self.assert_correct_chain(input_dominoes, output_chain)
+
+    def test_separate_loops(self):
+        input_dominoes = [(1, 2), (2, 3), (3, 1), (1, 1), (2, 2), (3, 3)]
+        output_chain = chain(input_dominoes)
+        self.assert_correct_chain(input_dominoes, output_chain)
+
+    def test_nine_elements(self):
+        input_dominoes = [(1, 2), (5, 3), (3, 1), (1, 2), (2, 4), (1, 6),
+                          (2, 3), (3, 4), (5, 6)]
+        output_chain = chain(input_dominoes)
+        self.assert_correct_chain(input_dominoes, output_chain)
+
+    # Utility methods
+
+    def normalize_dominoes(self, dominoes):
+        return list(sorted(tuple(sorted(domino)) for domino in dominoes))
+
+    def assert_same_dominoes(self, input_dominoes, output_chain):
+        msg = ('Dominoes used in the output must be the same '
+               'as the ones given in the input')
+        input_normal = self.normalize_dominoes(input_dominoes)
+        output_normal = self.normalize_dominoes(output_chain)
+        self.assertEqual(input_normal, output_normal, msg)
+
+    def assert_consecutive_dominoes_match(self, output_chain):
+        for i in range(len(output_chain) - 1):
+            msg = ("In chain {}, right end of domino {} ({}) "
+                   "and left end of domino {} ({}) must match")
+            msg = msg.format(output_chain,
+                             i,
+                             output_chain[i],
+                             i + 1,
+                             output_chain[i + 1])
+            self.assertEqual(output_chain[i][1], output_chain[i + 1][0], msg)
+
+    def assert_dominoes_at_ends_match(self, output_chain):
+        msg = ("In chain {}, left end of first domino ({}) and "
+               "right end of last domino ({}) must match")
+        msg = msg.format(output_chain, output_chain[0], output_chain[-1])
+        self.assertEqual(output_chain[0][0], output_chain[-1][1], msg)
+
+    def assert_correct_chain(self, input_dominoes, output_chain):
+        msg = 'There should be a chain for {}'.format(input_dominoes)
+        self.assertIsNotNone(output_chain, msg)
+        self.assert_same_dominoes(input_dominoes, output_chain)
+        if not any(output_chain):
+            return
+        self.assert_consecutive_dominoes_match(output_chain)
+        self.assert_dominoes_at_ends_match(output_chain)
+
+    def refute_correct_chain(self, input_dominoes, output_chain):
+        msg = 'There should be no valid chain for {}'.format(input_dominoes)
+        self.assertIsNone(output_chain, msg)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/dominoes/example.py

@@ -0,0 +1,30 @@
+from itertools import permutations
+from functools import reduce
+
+
+def swap(a, b):
+    return (b, a)
+
+
+def build_chain(chain, domino):
+    if chain is not None:
+        last = chain[-1]
+        if len(chain) == 1 and last[0] == domino[0]:
+            return [swap(*last), domino]
+        elif len(chain) == 1 and last[0] == domino[1]:
+            return [swap(*last), swap(*domino)]
+        elif last[1] == domino[0]:
+            return chain + [domino]
+        elif last[1] == domino[1]:
+            return chain + [swap(*domino)]
+    return None
+
+
+def chain(dominoes):
+    if not any(dominoes):
+        return []
+    for perm in permutations(dominoes):
+        chain = reduce(build_chain, perm[1:], [perm[0]])
+        if chain is not None and chain[0][0] == chain[-1][1]:
+            return chain
+    return None

data/tracks/python/exercises/grains/grains_test.py

@@ -6,34 +6,29 @@ from grains import (
 )
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class GrainsTest(unittest.TestCase):
     def test_square_1(self):
         self.assertEqual(on_square(1), 1)
-        self.assertEqual(total_after(1), 1)
 
     def test_square_2(self):
         self.assertEqual(on_square(2), 2)
-        self.assertEqual(total_after(2), 3)
 
     def test_square_3(self):
         self.assertEqual(on_square(3), 4)
-        self.assertEqual(total_after(3), 7)
 
     def test_square_4(self):
         self.assertEqual(on_square(4), 8)
-        self.assertEqual(total_after(4), 15)
 
     def test_square_16(self):
         self.assertEqual(on_square(16), 32768)
-        self.assertEqual(total_after(16), 65535)
 
     def test_square_32(self):
         self.assertEqual(on_square(32), 2147483648)
-        self.assertEqual(total_after(32), 4294967295)
 
     def test_square_64(self):
         self.assertEqual(on_square(64), 9223372036854775808)
-        self.assertEqual(total_after(64), 18446744073709551615)
 
     def test_square_0_raises_exception(self):
         with self.assertRaises(ValueError):
@@ -53,6 +48,9 @@ class GrainsTest(unittest.TestCase):
         with self.assertRaises(ValueError):
             total_after(65)
 
+    def test_total(self):
+        self.assertEqual(total_after(64), 18446744073709551615)
+
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/python/exercises/phone-number/example.py

@@ -4,21 +4,15 @@ import re
 class Phone(object):
     def __init__(self, number):
         self.number = self._clean(number)
-
-    def area_code(self):
-        return self.number[:3]
-
-    def exchange_code(self):
-        return self.number[3:6]
-
-    def subscriber_number(self):
-        return self.number[-4:]
+        self.area_code = self.number[:3]
+        self.exchange_code = self.number[3:6]
+        self.subscriber_number = self.number[-4:]
 
     def pretty(self):
         return "(%s) %s-%s" % (
-            self.area_code(),
-            self.exchange_code(),
-            self.subscriber_number()
+            self.area_code,
+            self.exchange_code,
+            self.subscriber_number
         )
 
     def _clean(self, number):
@@ -35,4 +29,4 @@ class Phone(object):
         if valid:
             return number[-10:]
         else:
-            return '0' * 10
+            raise ValueError()

data/tracks/python/exercises/phone-number/phone_number_test.py

@@ -19,12 +19,12 @@ class PhoneTest(unittest.TestCase):
         self.assertEqual(number, "2234567890")
 
     def test_invalid_when_9_digits(self):
-        number = Phone("123456789").number
-        self.assertEqual(number, "0000000000")
+        with self.assertRaises(ValueError):
+            Phone("123456789")
 
     def test_invalid_when_11_digits_and_first_not_1(self):
-        number = Phone("22234567890").number
-        self.assertEqual(number, "0000000000")
+        with self.assertRaises(ValueError):
+            Phone("22234567890")
 
     def test_valid_when_11_digits_and_first_is_1(self):
         number = Phone("12234567890").number
@@ -35,29 +35,29 @@ class PhoneTest(unittest.TestCase):
         self.assertEqual(number, "2234567890")
 
     def test_invalid_when_more_than_11_digits(self):
-        number = Phone("321234567890").number
-        self.assertEqual(number, "0000000000")
+        with self.assertRaises(ValueError):
+            Phone("321234567890")
 
     def test_invalid_with_letters(self):
-        number = Phone("123-abc-7890").number
-        self.assertEqual(number, "0000000000")
+        with self.assertRaises(ValueError):
+            Phone("123-abc-7890")
 
     def test_invalid_with_punctuation(self):
-        number = Phone("123-@:!-7890").number
-        self.assertEqual(number, "0000000000")
+        with self.assertRaises(ValueError):
+            Phone("123-@:!-7890")
 
     def test_invalid_area_code(self):
-        number = Phone("(123) 456-7890").number
-        self.assertEqual(number, "0000000000")
+        with self.assertRaises(ValueError):
+            Phone("(123) 456-7890")
 
     def test_invalid_exchange_code(self):
-        number = Phone("(223) 056-7890").number
-        self.assertEqual(number, "0000000000")
+        with self.assertRaises(ValueError):
+            Phone("(223) 056-7890")
 
     # Track specific tests
     def test_area_code(self):
         number = Phone("2234567890")
-        self.assertEqual(number.area_code(), "223")
+        self.assertEqual(number.area_code, "223")
 
     def test_pretty_print(self):
         number = Phone("2234567890")

data/tracks/python/exercises/poker/poker_test.py

@@ -3,81 +3,120 @@ import unittest
 from poker import poker
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class PokerTest(unittest.TestCase):
-    def test_one_hand(self):
+    def test_single_hand_wins(self):
         hand = '4S 5S 7H 8D JC'.split()
         self.assertEqual(poker([hand]), [hand])
 
-    def test_nothing_vs_one_pair(self):
-        nothing = '4S 5H 6S 8D JH'.split()
+    def highest_card_wins(self):
+        first = '4D 5S 6S 8D 3C'.split()
+        second = '2S 4C 7S 9H 10H'.split()
+        third = '3S 4S 5D 6H JH'.split()
+        self.assertEqual(poker([first, second, third]), [third])
+
+    def tie_has_multiple_winners(self):
+        first = '4D 5S 6S 8D 3C'.split()
+        second = '2S 4C 7S 9H 10H'.split()
+        third = '3S 4S 5D 6H JH'.split()
+        fourth = '3H 4H 5C 6C JD'.split()
+        self.assertEqual(
+            poker([first, second, third, fourth]),
+            [third, fourth])
+
+    def tie_compares_multiple(self):
+        higher = '3S 5H 6S 8D 7H'.split()
+        lower = '2S 5D 6D 8C 7S'.split()
+        self.assertEqual(poker([higher, lower]), [higher])
+
+    def pair_beats_high_card(self):
+        nothing = '4S 5H 6C 8D KH'.split()
         pairOf4 = '2S 4H 6S 4D JH'.split()
         self.assertEqual(poker([nothing, pairOf4]), [pairOf4])
 
-    def test_two_pair(self):
+    def highest_pair_wins(self):
         pairOf2 = '4S 2H 6S 2D JH'.split()
-        pairOf4 = '2S 4H 6S 4D JH'.split()
+        pairOf4 = '2S 4H 6C 4D JD'.split()
         self.assertEqual(poker([pairOf2, pairOf4]), [pairOf4])
 
-    def test_one_pair_vs_double_pair(self):
+    def two_pairs_beats_one_pair(self):
         pairOf8 = '2S 8H 6S 8D JH'.split()
-        doublePair = '4S 5H 4S 8D 5H'.split()
+        doublePair = '4S 5H 4C 8C 5C'.split()
         self.assertEqual(poker([pairOf8, doublePair]), [doublePair])
 
     def test_two_double_pair(self):
-        doublePair2and8 = '2S 8H 2S 8D JH'.split()
-        doublePair4and5 = '4S 5H 4S 8D 5H'.split()
+        doublePair2and8 = '2S 8H 2D 8D 3H'.split()
+        doublePair4and5 = '4S 5H 4C 8S 5D'.split()
         self.assertEqual(
             poker([doublePair2and8, doublePair4and5]), [doublePair2and8])
 
-    def test_two_double_pair_lower(self):
-        doublePair2and8 = '2S 8H 2S 8C JH'.split()
-        doublePair3and8 = '4S 3H 8S 8D 3H'.split()
+    def test_two_double_pair_higher_tie(self):
+        doublePair2andQ = '2S QS 2C QD JH'.split()
+        doublePairJandQ = 'JD QH JS 8D QC'.split()
         self.assertEqual(
-            poker([doublePair2and8, doublePair3and8]), [doublePair3and8])
+            poker([doublePair2andQ, doublePairJandQ]), [doublePairJandQ])
 
-    def test_two_double_pair_and_high(self):
-        doublePair2and8 = '2S 8H 2C 8C 3H'.split()
-        doublePair2and8high = '2D 2H 8S 8D AH'.split()
+    def test_two_double_pair_tie_kicker(self):
+        doublePair2and8high = 'JD QH JS 8D QC'.split()
+        doublePair2and8 = 'JS QS JC 2D QD'.split()
         self.assertEqual(
             poker([doublePair2and8high, doublePair2and8]),
             [doublePair2and8high])
 
-    def test_double_pair_vs_three(self):
-        doublePair2and8 = '2S 8H 2S 8D JH'.split()
-        threeOf4 = '4S 5H 4S 8D 4H'.split()
+    def three_beats_two_pair(self):
+        doublePair2and8 = '2S 8H 2H 8D JH'.split()
+        threeOf4 = '4S 5H 4C 8S 4H'.split()
         self.assertEqual(poker([doublePair2and8, threeOf4]), [threeOf4])
 
     def test_two_three(self):
-        threeOf2 = '2S 2H 2S 8D JH'.split()
-        threeOf1 = '4S AH AS 8D AH'.split()
+        threeOf2 = '2S 2H 2C 8D JH'.split()
+        threeOf1 = '4S AH AS 8C AD'.split()
         self.assertEqual(poker([threeOf2, threeOf1]), [threeOf1])
 
+    def test_two_three_multiple_decks(self):
+        threeOf1Low = '4S AH AS 7C AD'.split()
+        threeOf1High = '4S AH AS 8C AD'.split()
+        self.assertEqual(poker([threeOf1Low, threeOf1High]), [threeOf1High])
+
     def test_three_vs_straight(self):
-        threeOf4 = '4S 5H 4S 8D 4H'.split()
-        straight = '3S 4H 2S 6D 5H'.split()
+        threeOf4 = '4S 5H 4C 8D 4H'.split()
+        straight = '3S 4D 2S 6D 5C'.split()
+        self.assertEqual(poker([threeOf4, straight]), [straight])
+
+    def aces_can_end_straight(self):
+        threeOf4 = '4S 5H 4C 8D 4H'.split()
+        straight = '10D JH QS KD AC'.split()
+        self.assertEqual(poker([threeOf4, straight]), [straight])
+
+    def aces_can_start_straight(self):
+        threeOf4 = '4S 5H 4C 8D 4H'.split()
+        straight = '4D AH 3S 2D 5C'.split()
         self.assertEqual(poker([threeOf4, straight]), [straight])
 
     def test_two_straights(self):
-        straightTo8 = '4S 6H 7S 8D 5H'.split()
+        straightTo8 = '4S 6C 7S 8D 5H'.split()
         straightTo9 = '5S 7H 8S 9D 6H'.split()
         self.assertEqual(poker([straightTo8, straightTo9]), [straightTo9])
-        straightTo1 = 'AS QH KS TD JH'.split()
+
+    def test_two_straights_lowest(self):
+        straightTo6 = '2H 3C 4D 5D 6H'.split()
         straightTo5 = '4S AH 3S 2D 5H'.split()
-        self.assertEqual(poker([straightTo1, straightTo5]), [straightTo1])
+        self.assertEqual(poker([straightTo6, straightTo5]), [straightTo6])
 
     def test_straight_vs_flush(self):
-        straightTo8 = '4S 6H 7S 8D 5H'.split()
+        straightTo8 = '4C 6H 7D 8D 5H'.split()
         flushTo7 = '2S 4S 5S 6S 7S'.split()
         self.assertEqual(poker([straightTo8, flushTo7]), [flushTo7])
 
     def test_two_flushes(self):
-        flushTo8 = '3H 6H 7H 8H 5H'.split()
+        flushTo9 = '4H 7H 8H 9H 6H'.split()
         flushTo7 = '2S 4S 5S 6S 7S'.split()
-        self.assertEqual(poker([flushTo8, flushTo7]), [flushTo8])
+        self.assertEqual(poker([flushTo9, flushTo7]), [flushTo9])
 
     def test_flush_vs_full(self):
         flushTo8 = '3H 6H 7H 8H 5H'.split()
-        full = '4S 5H 4S 5D 4H'.split()
+        full = '4S 5H 4C 5D 4H'.split()
         self.assertEqual(poker([full, flushTo8]), [full])
 
     def test_two_fulls(self):
@@ -85,21 +124,31 @@ class PokerTest(unittest.TestCase):
         fullOf5by8 = '5H 5S 5D 8S 8D'.split()
         self.assertEqual(poker([fullOf4by9, fullOf5by8]), [fullOf5by8])
 
-    def test_full_vs_square(self):
-        full = '4S 5H 4S 5D 4H'.split()
-        squareOf3 = '3S 3H 2S 3D 3H'.split()
-        self.assertEqual(poker([full, squareOf3]), [squareOf3])
-
-    def test_two_square(self):
-        squareOf2 = '2S 2H 2S 8D 2H'.split()
-        squareOf5 = '4S 5H 5S 5D 5H'.split()
-        self.assertEqual(poker([squareOf2, squareOf5]), [squareOf5])
-
-    def test_square_vs_straight_flush(self):
-        squareOf5 = '4S 5H 5S 5D 5H'.split()
-        straightFlushTo9 = '5S 7S 8S 9S 6S'.split()
+    def test_two_fulls_same_triplet(self):
+        fullOf5by9 = '5H 5S 5D 9S 9D'.split()
+        fullOf5by8 = '5H 5S 5D 8S 8D'.split()
+        self.assertEqual(poker([fullOf5by9, fullOf5by8]), [fullOf5by9])
+
+    def test_full_vs_four(self):
+        full = '4S 5H 4D 5D 4H'.split()
+        fourOf3 = '3S 3H 2S 3D 3C'.split()
+        self.assertEqual(poker([full, fourOf3]), [fourOf3])
+
+    def test_two_fours(self):
+        fourOf2 = '2S 2H 2C 8D 2D'.split()
+        fourOf5 = '4S 5H 5S 5D 5C'.split()
+        self.assertEqual(poker([fourOf2, fourOf5]), [fourOf5])
+
+    def test_two_fours_kicker(self):
+        fourOf3low = '3S 3H 2S 3D 3C'.split()
+        fourOf3high = '3S 3H 4S 3D 3C'.split()
+        self.assertEqual(poker([fourOf3low, fourOf3high]), [fourOf3high])
+
+    def test_four_vs_straight_flush(self):
+        fourOf5 = '4S 5H 5S 5D 5C'.split()
+        straightFlushTo9 = '7S 8S 9S 6S 5S'.split()
         self.assertEqual(
-            poker([squareOf5, straightFlushTo9]), [straightFlushTo9])
+            poker([fourOf5, straightFlushTo9]), [straightFlushTo9])
 
     def test_two_straight_flushes(self):
         straightFlushTo8 = '4H 6H 7H 8H 5H'.split()
@@ -107,14 +156,6 @@ class PokerTest(unittest.TestCase):
         self.assertEqual(
             poker([straightFlushTo8, straightFlushTo9]), [straightFlushTo9])
 
-    def test_three_hand_with_tie(self):
-        spadeStraightTo9 = '9S 8S 7S 6S 5S'.split()
-        diamondStraightTo9 = '9D 8D 7D 6D 5D'.split()
-        threeOf4 = '4D 4S 4H QS KS'.split()
-        self.assertEqual(
-            poker([spadeStraightTo9, diamondStraightTo9, threeOf4]),
-            [spadeStraightTo9, diamondStraightTo9])
-
 
 if __name__ == '__main__':
     unittest.main()