python-study/tests12_3.py at main · dkochmashev/python-study · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import unittest
from runner_and_tournament import *


class RunnerTest(unittest.TestCase):
    is_frozen = False

    def runTest(self):
        self.test_walk()
        self.test_run()
        self.test_challenge()

    @unittest.skipIf(is_frozen, 'Тесты в этом кейсе заморожены')
    def test_walk(self):
        walker = Runner('Johnnie Walker')
        for i in range(10):
            walker.walk()
        self.assertEqual(walker.distance, 50)

    @unittest.skipIf(is_frozen, 'Тесты в этом кейсе заморожены')
    def test_run(self):
        runner = Runner('Forrest')
        for i in range(10):
            runner.run()
        self.assertEqual(runner.distance, 100)

    @unittest.skipIf(is_frozen, 'Тесты в этом кейсе заморожены')
    def test_challenge(self):
        runner1 = Runner('Beavis')
        runner2 = Runner('Butthead')
        for i in range(10):
            runner1.run()
            runner2.walk()
        self.assertNotEqual(runner1.distance, runner2.distance)


class FairTournament(Tournament):
    def start(self):
        finishers = {}
        place = 1
        by_speed = sorted(self.participants, key=lambda i: i.speed, reverse=True)
        while by_speed:
            for participant in by_speed:
                participant.run()
                if participant.distance >= self.full_distance:
                    finishers[place] = participant
                    place += 1
                    by_speed.remove(participant)
                    break

        return finishers


class TournamentTest(unittest.TestCase):
    is_frozen = True
    all_results = list()

    def runTest(self):
        self.test_1()
        self.test_2()
        self.test_3()
        self.test_4()

    @classmethod
    def setUpClass(cls):
        TournamentTest.all_results = list()

    def setUp(self):
        self.runners = {
            'Усэйн': Runner('Усэйн', 10),
            'Андрей': Runner('Андрей', 9),
            'Ник': Runner('Ник', 3)
        }

    @classmethod
    def tearDownClass(cls):
        for result in TournamentTest.all_results:
            print(result)

    def __add_results__(self, results):
        TournamentTest.all_results.append({place: results[place].name for place in results})

    # Усэйн и Ник
    @unittest.skipIf(is_frozen, 'Тесты в этом кейсе заморожены')
    def test_1(self):
        tournament = Tournament(90, self.runners['Усэйн'], self.runners['Ник'])
        self.assertIsNotNone(results := tournament.start())
        self.assertEqual(len(results), 2)
        self.assertNotEqual(results[1], results[2])
        self.assertEqual(results[1].name, 'Усэйн')
        self.assertEqual(results[2].name, 'Ник')
        self.__add_results__(results)

    # Андрей и Ник
    @unittest.skipIf(is_frozen, 'Тесты в этом кейсе заморожены')
    def test_2(self):
        tournament = Tournament(90, self.runners['Андрей'], self.runners['Ник'])
        self.assertIsNotNone(results := tournament.start())
        self.assertEqual(len(results), 2)
        self.assertNotEqual(results[1], results[2])
        self.assertEqual(results[1].name, 'Андрей')
        self.assertEqual(results[2].name, 'Ник')
        self.__add_results__(results)

    # Усэйн, Андрей и Ник.
    @unittest.skipIf(is_frozen, 'Тесты в этом кейсе заморожены')
    def test_3(self):
        tournament = Tournament(90, self.runners['Усэйн'], self.runners['Андрей'], self.runners['Ник'])
        self.assertIsNotNone(results := tournament.start())
        self.assertEqual(len(results), 3)
        self.assertNotEqual(results[1], results[2])
        self.assertNotEqual(results[1], results[3])
        self.assertNotEqual(results[2], results[3])
        self.assertEqual(results[1].name, 'Усэйн')
        self.assertEqual(results[2].name, 'Андрей')
        self.assertEqual(results[3].name, 'Ник')
        self.__add_results__(results)

    # Ошибка в алгоритме:
    # ---
    # Если значение скорости бегуна (Runner.speed) совпадает с дистанцией (Tournament.full_distance)
    # и бегун стоит первым в списке participants при конструировании Tournament, он будет на первом
    # месте в результатах забега, не смотря на то, что его скорость может быть ниже, чем у остальных
    # бегунов.
    #
    # Для выявления ошибки создан производный класс FairTournament с переопределением метода start,
    # и сравниваются результаты работы методов start() в вышеописанных условиях.

    @unittest.skipIf(is_frozen, 'Тесты в этом кейсе заморожены')
    def test_4(self):
        tournament = Tournament(3, self.runners['Ник'], self.runners['Усэйн'], self.runners['Андрей'])
        fair_tournament = FairTournament(3, self.runners['Ник'], self.runners['Усэйн'], self.runners['Андрей'])
        self.assertIsNotNone(results := tournament.start())
        fair_results = fair_tournament.start()
        self.assertDictEqual(results, fair_results, 'Неверный подсчет результатов в Tournament.start()')


test_suite = unittest.TestSuite()
test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(RunnerTest))
test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TournamentTest))

test_runner = unittest.TextTestRunner(verbosity=2)
test_runner.run(test_suite)