Ejemplo n.º 1
0
 def test_there_can_be_more_than_one_winner(self):
     results = ("Allegoric Alaskans;Blithering Badgers;loss\n"
                "Allegoric Alaskans;Blithering Badgers;win")
     table = ("Team                           | MP |  W |  D |  L |  P\n"
              "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3\n"
              "Blithering Badgers             |  2 |  1 |  0 |  1 |  3")
     self.assertEqual(tally(results), table)
Ejemplo n.º 2
0
 def test_there_can_be_more_than_one_winner(self):
     results = ('Allegoric Alaskans;Blithering Badgers;loss\n'
                'Allegoric Alaskans;Blithering Badgers;win')
     table = ('Team                           | MP |  W |  D |  L |  P\n'
              'Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3\n'
              'Blithering Badgers             |  2 |  1 |  0 |  1 |  3')
     self.assertEqual(tally(results), table)
Ejemplo n.º 3
0
 def test_there_can_be_more_than_one_winner(self):
     results = ['Allegoric Alaskans;Blithering Badgers;loss',
                'Allegoric Alaskans;Blithering Badgers;win']
     table = ['Team                           | MP |  W |  D |  L |  P',
              'Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3',
              'Blithering Badgers             |  2 |  1 |  0 |  1 |  3']
     self.assertEqual(tally(results), table)
Ejemplo n.º 4
0
 def test_there_can_be_more_than_one_match(self):
     results = ("Allegoric Alaskans;Blithering Badgers;win\n"
                "Allegoric Alaskans;Blithering Badgers;win")
     table = ("Team                           | MP |  W |  D |  L |  P\n"
              "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n"
              "Blithering Badgers             |  2 |  0 |  0 |  2 |  0")
     self.assertEqual(tally(results), table)
Ejemplo n.º 5
0
 def test_there_can_be_more_than_one_match(self):
     results = ('Allegoric Alaskans;Blithering Badgers;win\n'
                'Allegoric Alaskans;Blithering Badgers;win')
     table = ('Team                           | MP |  W |  D |  L |  P\n'
              'Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n'
              'Blithering Badgers             |  2 |  0 |  0 |  2 |  0')
     self.assertEqual(tally(results), table)
Ejemplo n.º 6
0
 def test_there_can_be_more_than_one_match(self):
     results = ['Allegoric Alaskans;Blithering Badgers;win',
                'Allegoric Alaskans;Blithering Badgers;win']
     table = ['Team                           | MP |  W |  D |  L |  P',
              'Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6',
              'Blithering Badgers             |  2 |  0 |  0 |  2 |  0']
     self.assertEqual(tally(results), table)
Ejemplo n.º 7
0
 def test_a_draw_is_one_point_each(self):
     results = ["Allegoric Alaskans;Blithering Badgers;draw"]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1",
         "Blithering Badgers             |  1 |  0 |  1 |  0 |  1",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 8
0
 def test_a_different_team_can_win(self):
     results = ["Blithering Badgers;Allegoric Alaskans;win"]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Blithering Badgers             |  1 |  1 |  0 |  0 |  3",
         "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 9
0
 def test_a_win_can_also_be_expressed_as_a_loss(self):
     results = ["Blithering Badgers;Allegoric Alaskans;loss"]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3",
         "Blithering Badgers             |  1 |  0 |  0 |  1 |  0",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 10
0
 def test_a_win_is_three_points_a_loss_is_zero_points(self):
     results = ["Allegoric Alaskans;Blithering Badgers;win"]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3",
         "Blithering Badgers             |  1 |  0 |  0 |  1 |  0",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 11
0
 def test_a_draw_is_one_point_each(self):
     results = ['Allegoric Alaskans;Blithering Badgers;draw']
     table = [
         'Team                           | MP |  W |  D |  L |  P',
         'Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1',
         'Blithering Badgers             |  1 |  0 |  1 |  0 |  1'
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 12
0
 def test_a_different_team_can_win(self):
     results = ['Blithering Badgers;Allegoric Alaskans;win']
     table = [
         'Team                           | MP |  W |  D |  L |  P',
         'Blithering Badgers             |  1 |  1 |  0 |  0 |  3',
         'Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0'
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 13
0
 def test_a_win_can_also_be_expressed_as_a_loss(self):
     results = ['Blithering Badgers;Allegoric Alaskans;loss']
     table = [
         'Team                           | MP |  W |  D |  L |  P',
         'Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3',
         'Blithering Badgers             |  1 |  0 |  0 |  1 |  0'
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 14
0
 def test_a_win_is_three_points_and_a_loss_is_zero_points(self):
     results = ['Allegoric Alaskans;Blithering Badgers;win']
     table = [
         'Team                           | MP |  W |  D |  L |  P',
         'Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3',
         'Blithering Badgers             |  1 |  0 |  0 |  1 |  0'
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 15
0
 def test_there_can_be_more_than_two_teams(self):
     results = ('Allegoric Alaskans;Blithering Badgers;win\n'
                'Blithering Badgers;Courageous Californians;win\n'
                'Courageous Californians;Allegoric Alaskans;loss')
     table = ('Team                           | MP |  W |  D |  L |  P\n'
              'Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n'
              'Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n'
              'Courageous Californians        |  2 |  0 |  0 |  2 |  0')
     self.assertEqual(tally(results), table)
Ejemplo n.º 16
0
 def test_there_can_be_more_than_two_teams(self):
     results = ("Allegoric Alaskans;Blithering Badgers;win\n"
                "Blithering Badgers;Courageous Californians;win\n"
                "Courageous Californians;Allegoric Alaskans;loss")
     table = ("Team                           | MP |  W |  D |  L |  P\n"
              "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n"
              "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n"
              "Courageous Californians        |  2 |  0 |  0 |  2 |  0")
     self.assertEqual(tally(results), table)
Ejemplo n.º 17
0
 def test_there_can_be_more_than_two_teams(self):
     results = ['Allegoric Alaskans;Blithering Badgers;win',
                'Blithering Badgers;Courageous Californians;win',
                'Courageous Californians;Allegoric Alaskans;loss']
     table = ['Team                           | MP |  W |  D |  L |  P',
              'Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6',
              'Blithering Badgers             |  2 |  1 |  0 |  1 |  3',
              'Courageous Californians        |  2 |  0 |  0 |  2 |  0']
     self.assertEqual(tally(results), table)
 def test_there_can_be_more_than_one_match(self):
     results = [
         "Allegoric Alaskans;Blithering Badgers;win",
         "Allegoric Alaskans;Blithering Badgers;win",
     ]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6",
         "Blithering Badgers             |  2 |  0 |  0 |  2 |  0",
     ]
     assert tally(results) == table
Ejemplo n.º 19
0
 def test_there_can_be_more_than_one_match(self):
     results = [
         'Allegoric Alaskans;Blithering Badgers;win',
         'Allegoric Alaskans;Blithering Badgers;win'
     ]
     table = [
         'Team                           | MP |  W |  D |  L |  P',
         'Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6',
         'Blithering Badgers             |  2 |  0 |  0 |  2 |  0'
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 20
0
 def test_there_can_be_more_than_one_winner(self):
     results = [
         'Allegoric Alaskans;Blithering Badgers;loss',
         'Allegoric Alaskans;Blithering Badgers;win'
     ]
     table = [
         'Team                           | MP |  W |  D |  L |  P',
         'Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3',
         'Blithering Badgers             |  2 |  1 |  0 |  1 |  3'
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 21
0
 def test_there_can_be_more_than_one_winner(self):
     results = [
         "Allegoric Alaskans;Blithering Badgers;loss",
         "Allegoric Alaskans;Blithering Badgers;win",
     ]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3",
         "Blithering Badgers             |  2 |  1 |  0 |  1 |  3",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 22
0
    def test_incomplete_competitionnot_not_all_pairs_have_played(self):
        results = ['Allegoric Alaskans;Blithering Badgers;loss',
                   'Devastating Donkeys;Allegoric Alaskans;loss',
                   'Courageous Californians;Blithering Badgers;draw',
                   'Allegoric Alaskans;Courageous Californians;win']

        table = ['Team                           | MP |  W |  D |  L |  P',
                 'Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6',
                 'Blithering Badgers             |  2 |  1 |  1 |  0 |  4',
                 'Courageous Californians        |  2 |  0 |  1 |  1 |  1',
                 'Devastating Donkeys            |  1 |  0 |  0 |  1 |  0']

        self.assertEqual(tally(results), table)
Ejemplo n.º 23
0
    def test_incomplete_competitionnot_not_all_pairs_have_played(self):
        results = ("Allegoric Alaskans;Blithering Badgers;loss\n"
                   "Devastating Donkeys;Allegoric Alaskans;loss\n"
                   "Courageous Californians;Blithering Badgers;draw\n"
                   "Allegoric Alaskans;Courageous Californians;win")

        table = ("Team                           | MP |  W |  D |  L |  P\n"
                 "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n"
                 "Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n"
                 "Courageous Californians        |  2 |  0 |  1 |  1 |  1\n"
                 "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0")

        self.assertEqual(tally(results), table)
Ejemplo n.º 24
0
 def test_there_can_be_more_than_two_teams(self):
     results = [
         'Allegoric Alaskans;Blithering Badgers;win',
         'Blithering Badgers;Courageous Californians;win',
         'Courageous Californians;Allegoric Alaskans;loss'
     ]
     table = [
         'Team                           | MP |  W |  D |  L |  P',
         'Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6',
         'Blithering Badgers             |  2 |  1 |  0 |  1 |  3',
         'Courageous Californians        |  2 |  0 |  0 |  2 |  0'
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 25
0
 def test_there_can_be_more_than_two_teams(self):
     results = [
         "Allegoric Alaskans;Blithering Badgers;win",
         "Blithering Badgers;Courageous Californians;win",
         "Courageous Californians;Allegoric Alaskans;loss",
     ]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6",
         "Blithering Badgers             |  2 |  1 |  0 |  1 |  3",
         "Courageous Californians        |  2 |  0 |  0 |  2 |  0",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 26
0
    def test_incomplete_competitionnot_not_all_pairs_have_played(self):
        results = ('Allegoric Alaskans;Blithering Badgers;loss\n'
                   'Devastating Donkeys;Allegoric Alaskans;loss\n'
                   'Courageous Californians;Blithering Badgers;draw\n'
                   'Allegoric Alaskans;Courageous Californians;win')

        table = ('Team                           | MP |  W |  D |  L |  P\n'
                 'Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n'
                 'Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n'
                 'Courageous Californians        |  2 |  0 |  1 |  1 |  1\n'
                 'Devastating Donkeys            |  1 |  0 |  0 |  1 |  0')

        self.assertEqual(tally(results), table)
Ejemplo n.º 27
0
 def test_ensure_points_sorted_numerically(self):
     results = [
         "Devastating Donkeys;Blithering Badgers;win",
         "Devastating Donkeys;Blithering Badgers;win",
         "Devastating Donkeys;Blithering Badgers;win",
         "Devastating Donkeys;Blithering Badgers;win",
         "Blithering Badgers;Devastating Donkeys;win",
     ]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Devastating Donkeys            |  5 |  4 |  0 |  1 | 12",
         "Blithering Badgers             |  5 |  1 |  0 |  4 |  3",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 28
0
    def test_typical_input(self):
        results = ("Allegoric Alaskans;Blithering Badgers;win\n"
                   "Devastating Donkeys;Courageous Californians;draw\n"
                   "Devastating Donkeys;Allegoric Alaskans;win\n"
                   "Courageous Californians;Blithering Badgers;loss\n"
                   "Blithering Badgers;Devastating Donkeys;loss\n"
                   "Allegoric Alaskans;Courageous Californians;win")

        table = ("Team                           | MP |  W |  D |  L |  P\n"
                 "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n"
                 "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n"
                 "Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n"
                 "Courageous Californians        |  3 |  0 |  1 |  2 |  1")

        self.assertEqual(tally(results), table)
Ejemplo n.º 29
0
    def test_ties_broken_alphabetically(self):
        results = ['Courageous Californians;Devastating Donkeys;win',
                   'Allegoric Alaskans;Blithering Badgers;win',
                   'Devastating Donkeys;Allegoric Alaskans;loss',
                   'Courageous Californians;Blithering Badgers;win',
                   'Blithering Badgers;Devastating Donkeys;draw',
                   'Allegoric Alaskans;Courageous Californians;draw']

        table = ['Team                           | MP |  W |  D |  L |  P',
                 'Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7',
                 'Courageous Californians        |  3 |  2 |  1 |  0 |  7',
                 'Blithering Badgers             |  3 |  0 |  1 |  2 |  1',
                 'Devastating Donkeys            |  3 |  0 |  1 |  2 |  1']

        self.assertEqual(tally(results), table)
Ejemplo n.º 30
0
 def test_incomplete_competition_not_all_pairs_have_played(self):
     results = [
         "Allegoric Alaskans;Blithering Badgers;loss",
         "Devastating Donkeys;Allegoric Alaskans;loss",
         "Courageous Californians;Blithering Badgers;draw",
         "Allegoric Alaskans;Courageous Californians;win",
     ]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6",
         "Blithering Badgers             |  2 |  1 |  1 |  0 |  4",
         "Courageous Californians        |  2 |  0 |  1 |  1 |  1",
         "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0",
     ]
     self.assertEqual(tally(results), table)
Ejemplo n.º 31
0
    def test_ties_broken_alphabetically(self):
        results = ('Courageous Californians;Devastating Donkeys;win\n'
                   'Allegoric Alaskans;Blithering Badgers;win\n'
                   'Devastating Donkeys;Allegoric Alaskans;loss\n'
                   'Courageous Californians;Blithering Badgers;win\n'
                   'Blithering Badgers;Devastating Donkeys;draw\n'
                   'Allegoric Alaskans;Courageous Californians;draw')

        table = ('Team                           | MP |  W |  D |  L |  P\n'
                 'Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n'
                 'Courageous Californians        |  3 |  2 |  1 |  0 |  7\n'
                 'Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n'
                 'Devastating Donkeys            |  3 |  0 |  1 |  2 |  1')

        self.assertEqual(tally(results), table)
Ejemplo n.º 32
0
    def test_typical_input(self):
        results = ('Allegoric Alaskans;Blithering Badgers;win\n'
                   'Devastating Donkeys;Courageous Californians;draw\n'
                   'Devastating Donkeys;Allegoric Alaskans;win\n'
                   'Courageous Californians;Blithering Badgers;loss\n'
                   'Blithering Badgers;Devastating Donkeys;loss\n'
                   'Allegoric Alaskans;Courageous Californians;win')

        table = ('Team                           | MP |  W |  D |  L |  P\n'
                 'Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n'
                 'Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n'
                 'Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n'
                 'Courageous Californians        |  3 |  0 |  1 |  2 |  1')

        self.assertEqual(tally(results), table)
Ejemplo n.º 33
0
    def test_ties_broken_alphabetically(self):
        results = ("Courageous Californians;Devastating Donkeys;win\n"
                   "Allegoric Alaskans;Blithering Badgers;win\n"
                   "Devastating Donkeys;Allegoric Alaskans;loss\n"
                   "Courageous Californians;Blithering Badgers;win\n"
                   "Blithering Badgers;Devastating Donkeys;draw\n"
                   "Allegoric Alaskans;Courageous Californians;draw")

        table = ("Team                           | MP |  W |  D |  L |  P\n"
                 "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n"
                 "Courageous Californians        |  3 |  2 |  1 |  0 |  7\n"
                 "Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n"
                 "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1")

        self.assertEqual(tally(results), table)
Ejemplo n.º 34
0
    def test_incomplete_competitionnot_not_all_pairs_have_played(self):
        results = [
            'Allegoric Alaskans;Blithering Badgers;loss',
            'Devastating Donkeys;Allegoric Alaskans;loss',
            'Courageous Californians;Blithering Badgers;draw',
            'Allegoric Alaskans;Courageous Californians;win'
        ]

        table = [
            'Team                           | MP |  W |  D |  L |  P',
            'Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6',
            'Blithering Badgers             |  2 |  1 |  1 |  0 |  4',
            'Courageous Californians        |  2 |  0 |  1 |  1 |  1',
            'Devastating Donkeys            |  1 |  0 |  0 |  1 |  0'
        ]

        self.assertEqual(tally(results), table)
Ejemplo n.º 35
0
 def test_typical_input(self):
     results = [
         "Allegoric Alaskans;Blithering Badgers;win",
         "Devastating Donkeys;Courageous Californians;draw",
         "Devastating Donkeys;Allegoric Alaskans;win",
         "Courageous Californians;Blithering Badgers;loss",
         "Blithering Badgers;Devastating Donkeys;loss",
         "Allegoric Alaskans;Courageous Californians;win",
     ]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7",
         "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6",
         "Blithering Badgers             |  3 |  1 |  0 |  2 |  3",
         "Courageous Californians        |  3 |  0 |  1 |  2 |  1",
     ]
     self.assertEqual(tally(results), table)
 def test_ties_broken_alphabetically(self):
     results = [
         "Courageous Californians;Devastating Donkeys;win",
         "Allegoric Alaskans;Blithering Badgers;win",
         "Devastating Donkeys;Allegoric Alaskans;loss",
         "Courageous Californians;Blithering Badgers;win",
         "Blithering Badgers;Devastating Donkeys;draw",
         "Allegoric Alaskans;Courageous Californians;draw",
     ]
     table = [
         "Team                           | MP |  W |  D |  L |  P",
         "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7",
         "Courageous Californians        |  3 |  2 |  1 |  0 |  7",
         "Blithering Badgers             |  3 |  0 |  1 |  2 |  1",
         "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1",
     ]
     assert tally(results) == table
Ejemplo n.º 37
0
    def test_typical_input(self):
        results = [
            'Allegoric Alaskans;Blithering Badgers;win',
            'Devastating Donkeys;Courageous Californians;draw',
            'Devastating Donkeys;Allegoric Alaskans;win',
            'Courageous Californians;Blithering Badgers;loss',
            'Blithering Badgers;Devastating Donkeys;loss',
            'Allegoric Alaskans;Courageous Californians;win'
        ]

        table = [
            'Team                           | MP |  W |  D |  L |  P',
            'Devastating Donkeys            |  3 |  2 |  1 |  0 |  7',
            'Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6',
            'Blithering Badgers             |  3 |  1 |  0 |  2 |  3',
            'Courageous Californians        |  3 |  0 |  1 |  2 |  1'
        ]

        self.assertEqual(tally(results), table)
Ejemplo n.º 38
0
 def test_just_the_header_if_no_input(self):
     results = []
     table = ["Team                           | MP |  W |  D |  L |  P"]
     self.assertEqual(tally(results), table)
Ejemplo n.º 39
0
 def test_a_different_team_can_win(self):
     results = ['Blithering Badgers;Allegoric Alaskans;win']
     table = ['Team                           | MP |  W |  D |  L |  P',
              'Blithering Badgers             |  1 |  1 |  0 |  0 |  3',
              'Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0']
     self.assertEqual(tally(results), table)
Ejemplo n.º 40
0
 def test_a_win_is_three_points_and_a_loss_is_zero_points(self):
     results = 'Allegoric Alaskans;Blithering Badgers;win'
     table = ('Team                           | MP |  W |  D |  L |  P\n'
              'Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n'
              'Blithering Badgers             |  1 |  0 |  0 |  1 |  0')
     self.assertEqual(tally(results), table)
Ejemplo n.º 41
0
 def test_a_draw_is_one_point_each(self):
     results = ['Allegoric Alaskans;Blithering Badgers;draw']
     table = ['Team                           | MP |  W |  D |  L |  P',
              'Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1',
              'Blithering Badgers             |  1 |  0 |  1 |  0 |  1']
     self.assertEqual(tally(results), table)
Ejemplo n.º 42
0
 def test_a_different_team_can_win(self):
     results = 'Blithering Badgers;Allegoric Alaskans;win'
     table = ('Team                           | MP |  W |  D |  L |  P\n'
              'Blithering Badgers             |  1 |  1 |  0 |  0 |  3\n'
              'Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0')
     self.assertEqual(tally(results), table)
Ejemplo n.º 43
0
 def test_a_win_can_also_be_expressed_as_a_loss(self):
     results = 'Blithering Badgers;Allegoric Alaskans;loss'
     table = ('Team                           | MP |  W |  D |  L |  P\n'
              'Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n'
              'Blithering Badgers             |  1 |  0 |  0 |  1 |  0')
     self.assertEqual(tally(results), table)
Ejemplo n.º 44
0
 def test_a_draw_is_one_point_each(self):
     results = 'Allegoric Alaskans;Blithering Badgers;draw'
     table = ('Team                           | MP |  W |  D |  L |  P\n'
              'Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1\n'
              'Blithering Badgers             |  1 |  0 |  1 |  0 |  1')
     self.assertEqual(tally(results), table)
Ejemplo n.º 45
0
 def test_just_the_header_if_no_input(self):
     self.assertEqual(
         tally(''),
         'Team                           | MP |  W |  D |  L |  P'
     )
Ejemplo n.º 46
0
 def test_a_different_team_can_win(self):
     results = "Blithering Badgers;Allegoric Alaskans;win"
     table = ("Team                           | MP |  W |  D |  L |  P\n"
              "Blithering Badgers             |  1 |  1 |  0 |  0 |  3\n"
              "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0")
     self.assertEqual(tally(results), table)
Ejemplo n.º 47
0
 def test_just_the_header_if_no_input(self):
     self.assertEqual(
         tally(""),
         "Team                           | MP |  W |  D |  L |  P")
Ejemplo n.º 48
0
 def test_a_draw_is_one_point_each(self):
     results = "Allegoric Alaskans;Blithering Badgers;draw"
     table = ("Team                           | MP |  W |  D |  L |  P\n"
              "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1\n"
              "Blithering Badgers             |  1 |  0 |  1 |  0 |  1")
     self.assertEqual(tally(results), table)