truth table: tests and solutions

Nullary and Unary Operations tests

the code from truth_table/tests/test_nullary_unary.py from truth table: Nullary and Unary Operations

 1import src.truth_table
 2import unittest
 3
 4
 5class TestNullaryOperations(unittest.TestCase):
 6
 7    def test_logical_true(self):
 8        self.assertTrue(
 9            src.truth_table.logical_true()
10        )
11
12    def test_logical_false(self):
13        self.assertFalse(
14            src.truth_table.logical_false()
15        )
16
17
18class TestUnaryOperations(unittest.TestCase):
19
20    def test_logical_identity(self):
21        self.assertTrue(
22            src.truth_table.logical_identity(True)
23        )
24        self.assertFalse(
25            src.truth_table.logical_identity(False)
26        )
27
28    def test_logical_negation_aka_not(self):
29        self.assertFalse(
30            src.truth_table.logical_negation(True)
31        )
32        self.assertTrue(
33            src.truth_table.logical_negation(False)
34        )
35
36
37# Exceptions seen
38# AssertionError
39# AttributeError
40# TypeError

Binary Operations tests

Binary Operations 1 tests

the code from truth_table/tests/test_binary.py from truth table: Binary Operations 1

 1import src.truth_table
 2import unittest
 3
 4
 5class TestBinaryOperations(unittest.TestCase):
 6
 7    def test_contradiction(self):
 8        contradiction = src.truth_table.contradiction
 9        self.assertFalse(contradiction(True, True))
10        self.assertFalse(contradiction(True, False))
11        self.assertFalse(contradiction(False, True))
12        self.assertFalse(contradiction(False, False))
13
14    def test_logical_conjunction(self):
15        logical_conjunction = (
16            src.truth_table.logical_conjunction
17        )
18        self.assertTrue(
19            logical_conjunction(True, True)
20        )
21        self.assertFalse(
22            logical_conjunction(True, False)
23        )
24        self.assertFalse(
25            logical_conjunction(False, True)
26        )
27        self.assertFalse(
28            logical_conjunction(False, False)
29        )
30
31    def test_project_second(self):
32        project_second = src.truth_table.project_second
33        self.assertTrue(project_second(True, True))
34        self.assertFalse(project_second(True, False))
35        self.assertTrue(project_second(False, True))
36        self.assertFalse(project_second(False, False))
37
38    def test_converse_non_implication(self):
39        converse_non_implication = (
40            src.truth_table.converse_non_implication
41        )
42        self.assertFalse(
43            converse_non_implication(True, True)
44        )
45        self.assertFalse(
46            converse_non_implication(True, False)
47        )
48        self.assertTrue(
49            converse_non_implication(False, True)
50        )
51        self.assertFalse(
52            converse_non_implication(False, False)
53        )
54
55
56# Exceptions seen
57# AttributeError
58# TypeError
59# AssertionError

Binary Operations 2 tests

the code from truth_table/tests/test_binary.py from truth table: Binary Operations 2

  1import src.truth_table
  2import unittest
  3
  4
  5class TestBinaryOperations(unittest.TestCase):
  6
  7    def test_contradiction(self):
  8        self.assertFalse(
  9            src.truth_table.contradiction(True, True)
 10        )
 11        self.assertFalse(
 12            src.truth_table.contradiction(True, False)
 13        )
 14        self.assertFalse(
 15            src.truth_table.contradiction(False, True)
 16        )
 17        self.assertFalse(
 18            src.truth_table.contradiction(False, False)
 19        )
 20
 21    def test_logical_conjunction(self):
 22        self.assertTrue(
 23            src.truth_table.logical_conjunction(
 24                True, True
 25            )
 26        )
 27        self.assertFalse(
 28            src.truth_table.logical_conjunction(
 29                True, False
 30            )
 31        )
 32        self.assertFalse(
 33            src.truth_table.logical_conjunction(
 34                False, True
 35            )
 36        )
 37        self.assertFalse(
 38            src.truth_table.logical_conjunction(
 39                False, False
 40            )
 41        )
 42
 43    def test_project_second(self):
 44        self.assertTrue(
 45            src.truth_table.project_second(True, True)
 46        )
 47        self.assertFalse(
 48            src.truth_table.project_second(True, False)
 49        )
 50        self.assertTrue(
 51            src.truth_table.project_second(False, True)
 52        )
 53        self.assertFalse(
 54            src.truth_table.project_second(False, False)
 55        )
 56
 57    def test_converse_non_implication(self):
 58        self.assertFalse(
 59            src.truth_table.converse_non_implication(
 60                True, True
 61            )
 62        )
 63        self.assertFalse(
 64            src.truth_table.converse_non_implication(
 65                True, False
 66            )
 67        )
 68        self.assertTrue(
 69            src.truth_table.converse_non_implication(
 70                False, True
 71            )
 72        )
 73        self.assertFalse(
 74            src.truth_table.converse_non_implication(
 75                False, False
 76            )
 77        )
 78
 79    def test_negate_first(self):
 80        self.assertFalse(
 81            src.truth_table.negate_first(True, True)
 82        )
 83        self.assertFalse(
 84            src.truth_table.negate_first(True, False)
 85        )
 86        self.assertTrue(
 87            src.truth_table.negate_first(False, True)
 88        )
 89        self.assertTrue(
 90            src.truth_table.negate_first(False, False)
 91        )
 92
 93    def test_logical_nand(self):
 94        self.assertFalse(
 95            src.truth_table.logical_nand(True, True)
 96        )
 97        self.assertTrue(
 98            src.truth_table.logical_nand(True, False)
 99        )
100        self.assertTrue(
101            src.truth_table.logical_nand(False, True)
102        )
103        self.assertTrue(
104            src.truth_table.logical_nand(False, False)
105        )
106
107    def test_tautology(self):
108        self.assertTrue(
109            src.truth_table.tautology(True, True)
110        )
111        self.assertTrue(
112            src.truth_table.tautology(True, False)
113        )
114        self.assertTrue(
115            src.truth_table.tautology(False, True)
116        )
117        self.assertTrue(
118            src.truth_table.tautology(False, False)
119        )
120
121    def test_logical_disjunction(self):
122        self.assertTrue(
123            src.truth_table.logical_disjunction(
124                True, True
125            )
126        )
127        self.assertTrue(
128            src.truth_table.logical_disjunction(
129                True, False
130            )
131        )
132        self.assertTrue(
133            src.truth_table.logical_disjunction(
134                False, True
135            )
136        )
137        self.assertFalse(
138            src.truth_table.logical_disjunction(
139                False, False
140            )
141        )
142
143
144# Exceptions seen
145# AttributeError
146# TypeError
147# AssertionError
148# SyntaxError

Binary Operations 3 tests

the code from truth_table/tests/test_binary.py from truth table: Binary Operations 3

  1import src.truth_table
  2import unittest
  3
  4
  5class TestBinaryOperations(unittest.TestCase):
  6
  7    def test_contradiction(self):
  8        self.assertFalse(
  9            src.truth_table.contradiction(True, True)
 10        )
 11        self.assertFalse(
 12            src.truth_table.contradiction(True, False)
 13        )
 14        self.assertFalse(
 15            src.truth_table.contradiction(False, True)
 16        )
 17        self.assertFalse(
 18            src.truth_table.contradiction(False, False)
 19        )
 20
 21    def test_logical_conjunction(self):
 22        self.assertTrue(
 23            src.truth_table.logical_conjunction(
 24                True, True
 25            )
 26        )
 27        self.assertFalse(
 28            src.truth_table.logical_conjunction(
 29                True, False
 30            )
 31        )
 32        self.assertFalse(
 33            src.truth_table.logical_conjunction(
 34                False, True
 35            )
 36        )
 37        self.assertFalse(
 38            src.truth_table.logical_conjunction(
 39                False, False
 40            )
 41        )
 42
 43    def test_project_second(self):
 44        self.assertTrue(
 45            src.truth_table.project_second(True, True)
 46        )
 47        self.assertFalse(
 48            src.truth_table.project_second(True, False)
 49        )
 50        self.assertTrue(
 51            src.truth_table.project_second(False, True)
 52        )
 53        self.assertFalse(
 54            src.truth_table.project_second(False, False)
 55        )
 56
 57    def test_converse_non_implication(self):
 58        self.assertFalse(
 59            src.truth_table.converse_non_implication(
 60                True, True
 61            )
 62        )
 63        self.assertFalse(
 64            src.truth_table.converse_non_implication(
 65                True, False
 66            )
 67        )
 68        self.assertTrue(
 69            src.truth_table.converse_non_implication(
 70                False, True
 71            )
 72        )
 73        self.assertFalse(
 74            src.truth_table.converse_non_implication(
 75                False, False
 76            )
 77        )
 78
 79    def test_negate_first(self):
 80        self.assertFalse(
 81            src.truth_table.negate_first(True, True)
 82        )
 83        self.assertFalse(
 84            src.truth_table.negate_first(True, False)
 85        )
 86        self.assertTrue(
 87            src.truth_table.negate_first(False, True)
 88        )
 89        self.assertTrue(
 90            src.truth_table.negate_first(False, False)
 91        )
 92
 93    def test_logical_nand(self):
 94        self.assertFalse(
 95            src.truth_table.logical_nand(True, True)
 96        )
 97        self.assertTrue(
 98            src.truth_table.logical_nand(True, False)
 99        )
100        self.assertTrue(
101            src.truth_table.logical_nand(False, True)
102        )
103        self.assertTrue(
104            src.truth_table.logical_nand(False, False)
105        )
106
107    def test_tautology(self):
108        self.assertTrue(
109            src.truth_table.tautology(True, True)
110        )
111        self.assertTrue(
112            src.truth_table.tautology(True, False)
113        )
114        self.assertTrue(
115            src.truth_table.tautology(False, True)
116        )
117        self.assertTrue(
118            src.truth_table.tautology(False, False)
119        )
120
121    def test_logical_disjunction(self):
122        self.assertTrue(
123            src.truth_table.logical_disjunction(
124                True, True
125            )
126        )
127        self.assertTrue(
128            src.truth_table.logical_disjunction(
129                True, False
130            )
131        )
132        self.assertTrue(
133            src.truth_table.logical_disjunction(
134                False, True
135            )
136        )
137        self.assertFalse(
138            src.truth_table.logical_disjunction(
139                False, False
140            )
141        )
142
143    def test_exclusive_disjunction(self):
144        self.assertFalse(
145            src.truth_table.exclusive_disjunction(
146                True, True
147            )
148        )
149        self.assertTrue(
150            src.truth_table.exclusive_disjunction(
151                True, False
152            )
153        )
154        self.assertTrue(
155            src.truth_table.exclusive_disjunction(
156                False, True
157            )
158        )
159        self.assertFalse(
160            src.truth_table.exclusive_disjunction(
161                False, False
162            )
163        )
164
165    def test_material_non_implication(self):
166        self.assertFalse(
167            src.truth_table.material_non_implication(
168                True, True
169            )
170        )
171        self.assertTrue(
172            src.truth_table.material_non_implication(
173                True, False
174            )
175        )
176        self.assertFalse(
177            src.truth_table.material_non_implication(
178                False, True
179            )
180        )
181        self.assertFalse(
182            src.truth_table.material_non_implication(
183                False, False
184            )
185        )
186
187    def test_project_first(self):
188        self.assertTrue(
189            src.truth_table.project_first(True, True)
190        )
191        self.assertTrue(
192            src.truth_table.project_first(True, False)
193        )
194        self.assertFalse(
195            src.truth_table.project_first(False, True)
196        )
197        self.assertFalse(
198            src.truth_table.project_first(False, False)
199        )
200
201    def test_converse_implication(self):
202        self.assertTrue(
203            src.truth_table.converse_implication(
204                True, True
205            )
206        )
207        self.assertTrue(
208            src.truth_table.converse_implication(
209                True, False
210            )
211        )
212        self.assertFalse(
213            src.truth_table.converse_implication(
214                False, True
215            )
216        )
217        self.assertTrue(
218            src.truth_table.converse_implication(
219                False, False
220            )
221        )
222
223
224# Exceptions seen
225# AttributeError
226# TypeError
227# AssertionError
228# SyntaxError

Binary Operations 4 tests

the code from truth_table/tests/test_binary.py from truth table: Binary Operations 4

solutions

the solutions in truth_table/src/truth_table.py from truth table

  1def logical_true():
  2    return True
  3
  4
  5def logical_false():
  6    return False
  7
  8
  9def logical_identity(the_input):
 10    return the_input
 11
 12
 13def logical_negation(the_input):
 14    return not the_input
 15
 16
 17def contradiction(first_input, second_input):
 18    return False
 19
 20
 21def logical_conjunction(first_input, second_input):
 22    return first_input and second_input
 23
 24
 25def project_second(first_input, second_input):
 26    return second_input
 27
 28
 29def converse_non_implication(first_input, second_input):
 30    return logical_conjunction(
 31        logical_negation(first_input),
 32        second_input
 33    )
 34    return not first_input and second_input
 35
 36
 37def negate_first(first_input, second_input):
 38    return not first_input
 39
 40
 41def logical_nand(first_input, second_input):
 42    return logical_negation(
 43        logical_conjunction(first_input, second_input)
 44    )
 45    return not (first_input and second_input)
 46
 47
 48def tautology(first_input, second_input):
 49    return True
 50
 51
 52def logical_disjunction(first_input, second_input):
 53    return logical_negation(
 54        logical_conjunction(
 55            logical_negation(first_input),
 56            logical_negation(second_input)
 57        )
 58    )
 59    return first_input or second_input
 60
 61
 62def exclusive_disjunction(first_input, second_input):
 63    return first_input != second_input
 64    return not (first_input == second_input)
 65    return logical_disjunction(
 66        converse_non_implication(
 67            first_input,
 68            second_input
 69        ),
 70        material_non_implication(
 71            first_input,
 72            second_input
 73        )
 74    )
 75    return (
 76        (not first_input and second_input)
 77        or
 78        (first_input and not second_input)
 79    )
 80
 81
 82def material_non_implication(first_input, second_input):
 83    return logical_conjunction(
 84        first_input,
 85        logical_negation(second_input)
 86    )
 87    return first_input and not second_input
 88
 89
 90def project_first(first_input, second_input):
 91    return first_input
 92
 93
 94def converse_implication(first_input, second_input):
 95    return logical_disjunction(
 96        first_input,
 97        logical_negation(second_input)
 98    )
 99    return first_input or not second_input
100
101
102def negate_second(first_input, second_input):
103    return not second_input
104
105
106def logical_nor(first_input, second_input):
107    return not (first_input or second_input)
108
109
110def logical_equality(first_input, second_input):
111    return first_input == second_input
112    return (
113        (first_input or not second_input)
114        and
115        (not first_input or second_input)
116    )
117
118
119def material_implication(first_input, second_input):
120    return not first_input or second_input

Traffic Light: tests and solutions

the code from traffic_light/tests/test_traffic_light.py from Traffic Light

  1import src.traffic_light
  2import unittest
  3
  4
  5RED, YELLOW, GREEN = 'RED', 'YELLOW', 'GREEN'
  6NO_WALK = 'NO WALK'
  7WALK = (RED, 'WALK')
  8YELLOW_NO_WALK = (YELLOW, NO_WALK)
  9GREEN_NO_WALK = (GREEN, NO_WALK)
 10
 11
 12class TestTrafficLight(unittest.TestCase):
 13
 14    def test_red_traffic_light_w_walk(self):
 15        self.assertEqual(
 16            src.traffic_light.show(
 17                current_light=RED,
 18                timer_done=True,
 19                walk_button=True,
 20            ),
 21            WALK
 22        )
 23
 24        self.assertEqual(
 25            src.traffic_light.show(
 26                current_light=RED,
 27                timer_done=True,
 28                walk_button=False,
 29            ),
 30            GREEN_NO_WALK
 31        )
 32
 33        self.assertEqual(
 34            src.traffic_light.show(
 35                current_light=RED,
 36                timer_done=False,
 37                walk_button=True,
 38            ),
 39            WALK
 40        )
 41
 42        self.assertEqual(
 43            src.traffic_light.show(
 44                current_light=RED,
 45                timer_done=False,
 46                walk_button=False,
 47            ),
 48            WALK
 49        )
 50
 51    def test_yellow_traffic_light_w_walk(self):
 52        self.assertEqual(
 53            src.traffic_light.show(
 54                current_light=YELLOW,
 55                timer_done=True,
 56                walk_button=True,
 57            ),
 58            WALK
 59        )
 60
 61        self.assertEqual(
 62            src.traffic_light.show(
 63                current_light=YELLOW,
 64                timer_done=True,
 65                walk_button=False,
 66            ),
 67            WALK
 68        )
 69
 70        self.assertEqual(
 71            src.traffic_light.show(
 72                current_light=YELLOW,
 73                timer_done=False,
 74                walk_button=True,
 75            ),
 76            YELLOW_NO_WALK
 77        )
 78
 79        self.assertEqual(
 80            src.traffic_light.show(
 81                current_light=YELLOW,
 82                timer_done=False,
 83                walk_button=False,
 84            ),
 85            YELLOW_NO_WALK
 86        )
 87
 88    def test_green_traffic_light_w_walk(self):
 89        self.assertEqual(
 90            src.traffic_light.show(
 91                current_light=GREEN,
 92                timer_done=True,
 93                walk_button=True,
 94            ),
 95            YELLOW_NO_WALK
 96        )
 97
 98        self.assertEqual(
 99            src.traffic_light.show(
100                current_light=GREEN,
101                timer_done=True,
102                walk_button=False,
103            ),
104            YELLOW_NO_WALK
105        )
106
107        self.assertEqual(
108            src.traffic_light.show(
109                current_light=GREEN,
110                timer_done=False,
111                walk_button=True,
112            ),
113            GREEN_NO_WALK
114        )
115
116        self.assertEqual(
117            src.traffic_light.show(
118                current_light=GREEN,
119                timer_done=False,
120                walk_button=False,
121            ),
122            GREEN_NO_WALK
123        )
124
125
126# Exceptions seen
127# AssertionError
128# NameError
129# AttributeError
130# TypeError
131# SyntaxError

the code from traffic_light/src/traffic_light.py from Traffic Light

 1def show(
 2        current_light='RED', timer_done=False,
 3        walk_button=False,
 4    ):
 5    red, yellow, green = 'RED', 'YELLOW', 'GREEN'
 6    walk = (red, 'WALK')
 7    no_walk = 'NO WALK'
 8
 9    if not timer_done and current_light != red:
10        return current_light, no_walk
11
12    if timer_done:
13        if current_light == green:
14            return yellow, no_walk
15        if current_light == red and not walk_button:
16            return green, no_walk
17
18    return walk

Automated Teller Machine: tests and solutions

the code from atm/tests/test_atm.py from Automated Teller Machine

  1import src.atm
  2import unittest
  3
  4
  5DENIED = 'DENIED'
  6
  7
  8class TestATM(unittest.TestCase):
  9
 10    def test_right_pin_enough_money_w_card(self):
 11        self.assertEqual(
 12            src.atm.withdraw(
 13                right_pin=True,
 14                enough_money=True,
 15                above_daily_limit=True,
 16                card_expired=True,
 17            ),
 18            DENIED
 19        )
 20
 21        self.assertEqual(
 22            src.atm.withdraw(
 23                right_pin=True,
 24                enough_money=True,
 25                above_daily_limit=True,
 26                card_expired=False,
 27            ),
 28            DENIED
 29        )
 30
 31        self.assertEqual(
 32            src.atm.withdraw(
 33                right_pin=True,
 34                enough_money=True,
 35                above_daily_limit=False,
 36                card_expired=True,
 37            ),
 38            DENIED
 39        )
 40
 41        self.assertEqual(
 42            src.atm.withdraw(
 43                right_pin=True,
 44                enough_money=True,
 45                above_daily_limit=False,
 46                card_expired=False,
 47            ),
 48            'CASH'
 49        )
 50
 51    def test_right_pin_not_enough_money_w_card(self):
 52        self.assertEqual(
 53            src.atm.withdraw(
 54                right_pin=True,
 55                enough_money=False,
 56                above_daily_limit=True,
 57                card_expired=True,
 58            ),
 59            DENIED
 60        )
 61
 62        self.assertEqual(
 63            src.atm.withdraw(
 64                right_pin=True,
 65                enough_money=False,
 66                above_daily_limit=True,
 67                card_expired=False,
 68            ),
 69            DENIED
 70        )
 71
 72        self.assertEqual(
 73            src.atm.withdraw(
 74                right_pin=True,
 75                enough_money=False,
 76                above_daily_limit=False,
 77                card_expired=True,
 78            ),
 79            DENIED
 80        )
 81
 82        self.assertEqual(
 83            src.atm.withdraw(
 84                right_pin=True,
 85                enough_money=False,
 86                above_daily_limit=False,
 87                card_expired=True,
 88            ),
 89            DENIED
 90        )
 91
 92    def test_wrong_pin_enough_money_w_card(self):
 93        self.assertEqual(
 94            src.atm.withdraw(
 95                right_pin=False,
 96                enough_money=True,
 97                above_daily_limit=True,
 98                card_expired=True,
 99            ),
100            DENIED
101        )
102
103        self.assertEqual(
104            src.atm.withdraw(
105                right_pin=False,
106                enough_money=True,
107                above_daily_limit=True,
108                card_expired=False,
109            ),
110            DENIED
111        )
112
113        self.assertEqual(
114            src.atm.withdraw(
115                right_pin=False,
116                enough_money=True,
117                above_daily_limit=False,
118                card_expired=True,
119            ),
120            DENIED
121        )
122
123        self.assertEqual(
124            src.atm.withdraw(
125                right_pin=False,
126                enough_money=True,
127                above_daily_limit=False,
128                card_expired=False,
129            ),
130            DENIED
131        )
132
133    def test_wrong_pin_not_enough_money_w_card(self):
134        self.assertEqual(
135            src.atm.withdraw(
136                right_pin=False,
137                enough_money=False,
138                above_daily_limit=True,
139                card_expired=True,
140            ),
141            DENIED
142        )
143
144        self.assertEqual(
145            src.atm.withdraw(
146                right_pin=False,
147                enough_money=False,
148                above_daily_limit=True,
149                card_expired=False,
150            ),
151            DENIED
152        )
153
154        self.assertEqual(
155            src.atm.withdraw(
156                right_pin=False,
157                enough_money=False,
158                above_daily_limit=False,
159                card_expired=True,
160            ),
161            DENIED
162        )
163
164        self.assertEqual(
165            src.atm.withdraw(
166                right_pin=False,
167                enough_money=False,
168                above_daily_limit=False,
169                card_expired=False,
170            ),
171            DENIED
172        )
173
174
175# Exceptions seen
176# AssertionError
177# NameError
178# AttributeError
179# TypeError
180# SyntaxError

the code from atm/src/atm.py from Automated Teller Machine

 1def withdraw(
 2        right_pin, enough_money,
 3        above_daily_limit=False, card_expired=False,
 4    ):
 5    denied = 'DENIED'
 6
 7    if card_expired:
 8        return denied
 9
10    if above_daily_limit:
11        return denied
12
13    if not right_pin:
14        return denied
15
16    if not enough_money:
17        return denied
18
19    return 'CASH'

Microwave: tests and solutions

the code from microwave/tests/test_microwave.py from Microwave

  1import src.microwave
  2import unittest
  3
  4
  5OFF = 'OFF'
  6
  7
  8class TestMicrowave(unittest.TestCase):
  9
 10    def test_too_hot_open_door_timer_set(self):
 11        self.assertEqual(
 12            src.microwave.microwave(
 13                door_is_open=True,
 14                timer_is_set=True,
 15                start_is_pushed=True,
 16                too_hot=True,
 17            ),
 18            OFF
 19        )
 20
 21        self.assertEqual(
 22            src.microwave.microwave(
 23                door_is_open=True,
 24                timer_is_set=True,
 25                start_is_pushed=True,
 26                too_hot=False,
 27            ),
 28            OFF
 29        )
 30
 31        self.assertEqual(
 32            src.microwave.microwave(
 33                door_is_open=True,
 34                timer_is_set=True,
 35                start_is_pushed=False,
 36                too_hot=True,
 37            ),
 38            OFF
 39        )
 40
 41        self.assertEqual(
 42            src.microwave.microwave(
 43                door_is_open=True,
 44                timer_is_set=True,
 45                start_is_pushed=False,
 46                too_hot=False,
 47            ),
 48            OFF
 49        )
 50
 51    def test_too_hot_open_door_timer_not_set(self):
 52        self.assertEqual(
 53            src.microwave.microwave(
 54                door_is_open=True,
 55                timer_is_set=False,
 56                start_is_pushed=True,
 57                too_hot=True,
 58            ),
 59            OFF
 60        )
 61
 62        self.assertEqual(
 63            src.microwave.microwave(
 64                door_is_open=True,
 65                timer_is_set=False,
 66                start_is_pushed=True,
 67                too_hot=False,
 68            ),
 69            OFF
 70        )
 71
 72        self.assertEqual(
 73            src.microwave.microwave(
 74                door_is_open=True,
 75                timer_is_set=False,
 76                start_is_pushed=False,
 77                too_hot=True,
 78            ),
 79            OFF
 80        )
 81
 82        self.assertEqual(
 83            src.microwave.microwave(
 84                door_is_open=True,
 85                timer_is_set=False,
 86                start_is_pushed=False,
 87                too_hot=False,
 88            ),
 89            OFF
 90        )
 91
 92    def test_too_hot_closed_door_timer_set(self):
 93        self.assertEqual(
 94            src.microwave.microwave(
 95                door_is_open=False,
 96                timer_is_set=True,
 97                start_is_pushed=True,
 98                too_hot=True,
 99            ),
100            OFF
101        )
102
103        self.assertEqual(
104            src.microwave.microwave(
105                door_is_open=False,
106                timer_is_set=True,
107                start_is_pushed=True,
108                too_hot=False,
109            ),
110            'HEATING'
111        )
112
113        self.assertEqual(
114            src.microwave.microwave(
115                door_is_open=False,
116                timer_is_set=True,
117                start_is_pushed=False,
118                too_hot=True,
119            ),
120            OFF
121        )
122
123        self.assertEqual(
124            src.microwave.microwave(
125                door_is_open=False,
126                timer_is_set=True,
127                start_is_pushed=False,
128                too_hot=False,
129            ),
130            OFF
131        )
132
133    def test_too_hot_closed_door_timer_not_set(self):
134        self.assertEqual(
135            src.microwave.microwave(
136                door_is_open=False,
137                timer_is_set=False,
138                start_is_pushed=True,
139                too_hot=True,
140            ),
141            OFF
142        )
143
144        self.assertEqual(
145            src.microwave.microwave(
146                door_is_open=False,
147                timer_is_set=False,
148                start_is_pushed=True,
149                too_hot=False,
150            ),
151            OFF
152        )
153
154        self.assertEqual(
155            src.microwave.microwave(
156                door_is_open=False,
157                timer_is_set=False,
158                start_is_pushed=False,
159                too_hot=True,
160            ),
161            OFF
162        )
163
164        self.assertEqual(
165            src.microwave.microwave(
166                door_is_open=False,
167                timer_is_set=False,
168                start_is_pushed=False,
169                too_hot=False,
170            ),
171            OFF
172        )
173
174
175# Exceptions seen
176# AssertionError
177# NameError
178# AttributeError
179# TypeError
180# SyntaxError

the code from microwave/src/microwave.py from Microwave

 1def microwave(
 2        door_is_open, start_is_pushed,
 3        timer_is_set=False, too_hot=False,
 4    ):
 5    off = 'OFF'
 6
 7    if too_hot:
 8        return off
 9    if not timer_is_set:
10        return off
11    if not start_is_pushed:
12        return off
13    if door_is_open:
14        return off
15
16    return 'HEATING'
17
18    if (
19        not door_is_open
20        and start_is_pushed
21        and timer_is_set
22        and not too_hot
23    ):
24        return 'HEATING'
25
26    return 'OFF'
27
28    if too_hot or not timer_is_set:
29        return 'OFF'
30
31    if door_is_open or not start_is_pushed:
32        return 'OFF'
33    else:
34        return 'HEATING'

Car: tests and solutions

the code from car/tests/test_car.py from Car

  1import src.car
  2import unittest
  3
  4
  5OFF = 'OFF'
  6
  7
  8class TestCar(unittest.TestCase):
  9
 10    def test_key_close_brake_pressed_w_gear(self):
 11        self.assertEqual(
 12            src.car.starter(
 13                key_is_close=True,
 14                brake_is_pressed=True,
 15                start_is_pushed=True,
 16                in_park=True,
 17            ),
 18            'ON'
 19        )
 20
 21        self.assertEqual(
 22            src.car.starter(
 23                key_is_close=True,
 24                brake_is_pressed=True,
 25                start_is_pushed=True,
 26                in_park=False,
 27            ),
 28            OFF
 29        )
 30
 31        self.assertEqual(
 32            src.car.starter(
 33                key_is_close=True,
 34                brake_is_pressed=True,
 35                start_is_pushed=False,
 36                in_park=True,
 37            ),
 38            OFF
 39        )
 40
 41        self.assertEqual(
 42            src.car.starter(
 43                key_is_close=True,
 44                brake_is_pressed=True,
 45                start_is_pushed=False,
 46                in_park=False,
 47            ),
 48            OFF
 49        )
 50
 51    def test_key_close_brake_not_pressed_w_gear(self):
 52        self.assertEqual(
 53            src.car.starter(
 54                key_is_close=True,
 55                brake_is_pressed=False,
 56                start_is_pushed=True,
 57                in_park=True,
 58            ),
 59            OFF
 60        )
 61
 62        self.assertEqual(
 63            src.car.starter(
 64                key_is_close=True,
 65                brake_is_pressed=False,
 66                start_is_pushed=True,
 67                in_park=False,
 68            ),
 69            OFF
 70        )
 71
 72        self.assertEqual(
 73            src.car.starter(
 74                key_is_close=True,
 75                brake_is_pressed=False,
 76                start_is_pushed=False,
 77                in_park=True,
 78            ),
 79            OFF
 80        )
 81
 82        self.assertEqual(
 83            src.car.starter(
 84                key_is_close=True,
 85                brake_is_pressed=False,
 86                start_is_pushed=False,
 87                in_park=False,
 88            ),
 89            OFF
 90        )
 91
 92    def test_key_far_brake_pressed_w_gear(self):
 93        self.assertEqual(
 94            src.car.starter(
 95                key_is_close=False,
 96                brake_is_pressed=True,
 97                start_is_pushed=True,
 98                in_park=True,
 99            ),
100            OFF
101        )
102
103        self.assertEqual(
104            src.car.starter(
105                key_is_close=False,
106                brake_is_pressed=True,
107                start_is_pushed=True,
108                in_park=False,
109            ),
110            OFF
111        )
112
113        self.assertEqual(
114            src.car.starter(
115                key_is_close=False,
116                brake_is_pressed=True,
117                start_is_pushed=False,
118                in_park=True,
119            ),
120            OFF
121        )
122
123        self.assertEqual(
124            src.car.starter(
125                key_is_close=False,
126                brake_is_pressed=True,
127                start_is_pushed=False,
128                in_park=False,
129            ),
130            OFF
131        )
132
133    def test_key_far_brake_not_pressed_w_gear(self):
134        self.assertEqual(
135            src.car.starter(
136                key_is_close=False,
137                brake_is_pressed=False,
138                start_is_pushed=True,
139                in_park=True,
140            ),
141            OFF
142        )
143
144        self.assertEqual(
145            src.car.starter(
146                key_is_close=False,
147                brake_is_pressed=False,
148                start_is_pushed=True,
149                in_park=False,
150            ),
151            OFF
152        )
153
154        self.assertEqual(
155            src.car.starter(
156                key_is_close=False,
157                brake_is_pressed=False,
158                start_is_pushed=False,
159                in_park=True,
160            ),
161            OFF
162        )
163
164        self.assertEqual(
165            src.car.starter(
166                key_is_close=False,
167                brake_is_pressed=False,
168                start_is_pushed=False,
169                in_park=False,
170            ),
171            OFF
172        )
173
174
175# Exceptions seen
176# AssertionError
177# NameError
178# AttributeError
179# TypeError
180# SyntaxError

the code from car/src/car.py from Car

 1def starter(
 2        key_is_close, start_is_pushed,
 3        brake_is_pressed=False, in_park=False,
 4    ):
 5    if not (
 6        key_is_close
 7        and start_is_pushed
 8        and brake_is_pressed
 9        and in_park
10    ):
11        return 'OFF'
12
13    return 'ON'

Elevator: tests and solutions

the code from elevator/tests/test_elevator.py from Elevator

  1import src.elevator
  2import unittest
  3
  4
  5NOT_MOVE = 'NOT MOVE'
  6
  7
  8class TestElevator(unittest.TestCase):
  9
 10    def test_doors_clear_number_pushed_w_emergency(self):
 11        self.assertEqual(
 12            src.elevator.elevator(
 13                doors_clear=True,
 14                number_pushed=True,
 15                above_weight_limit=True,
 16                emergency=True,
 17            ),
 18            NOT_MOVE
 19        )
 20
 21        self.assertEqual(
 22            src.elevator.elevator(
 23                doors_clear=True,
 24                number_pushed=True,
 25                above_weight_limit=True,
 26                emergency=False,
 27            ),
 28            NOT_MOVE
 29        )
 30
 31        self.assertEqual(
 32            src.elevator.elevator(
 33                doors_clear=True,
 34                number_pushed=True,
 35                above_weight_limit=False,
 36                emergency=True,
 37            ),
 38            NOT_MOVE
 39        )
 40
 41        self.assertEqual(
 42            src.elevator.elevator(
 43                doors_clear=True,
 44                number_pushed=True,
 45                above_weight_limit=False,
 46                emergency=False,
 47            ),
 48            'MOVE'
 49        )
 50
 51    def test_doors_clear_number_not_pushed_w_emergency(self):
 52        self.assertEqual(
 53            src.elevator.elevator(
 54                doors_clear=True,
 55                number_pushed=False,
 56                above_weight_limit=True,
 57                emergency=True,
 58            ),
 59            NOT_MOVE
 60        )
 61
 62        self.assertEqual(
 63            src.elevator.elevator(
 64                doors_clear=True,
 65                number_pushed=False,
 66                above_weight_limit=True,
 67                emergency=False,
 68            ),
 69            NOT_MOVE
 70        )
 71
 72        self.assertEqual(
 73            src.elevator.elevator(
 74                doors_clear=True,
 75                number_pushed=False,
 76                above_weight_limit=False,
 77                emergency=True,
 78            ),
 79            NOT_MOVE
 80        )
 81
 82        self.assertEqual(
 83            src.elevator.elevator(
 84                doors_clear=True,
 85                number_pushed=False,
 86                above_weight_limit=False,
 87                emergency=False,
 88            ),
 89            NOT_MOVE
 90        )
 91
 92    def test_doors_not_clear_number_pushed_w_emergency(self):
 93        self.assertEqual(
 94            src.elevator.elevator(
 95                doors_clear=False,
 96                number_pushed=True,
 97                above_weight_limit=True,
 98                emergency=True,
 99            ),
100            NOT_MOVE
101        )
102
103        self.assertEqual(
104            src.elevator.elevator(
105                doors_clear=False,
106                number_pushed=True,
107                above_weight_limit=True,
108                emergency=False,
109            ),
110            NOT_MOVE
111        )
112
113        self.assertEqual(
114            src.elevator.elevator(
115                doors_clear=False,
116                number_pushed=True,
117                above_weight_limit=False,
118                emergency=True,
119            ),
120            NOT_MOVE
121        )
122
123        self.assertEqual(
124            src.elevator.elevator(
125                doors_clear=False,
126                number_pushed=True,
127                above_weight_limit=False,
128                emergency=False,
129            ),
130            NOT_MOVE
131        )
132
133    def test_doors_not_clear_number_not_pushed_w_emergency(self):
134        self.assertEqual(
135            src.elevator.elevator(
136                doors_clear=False,
137                number_pushed=False,
138                above_weight_limit=True,
139                emergency=True,
140            ),
141            NOT_MOVE
142        )
143
144        self.assertEqual(
145            src.elevator.elevator(
146                doors_clear=False,
147                number_pushed=False,
148                above_weight_limit=True,
149                emergency=False,
150            ),
151            NOT_MOVE
152        )
153
154        self.assertEqual(
155            src.elevator.elevator(
156                doors_clear=False,
157                number_pushed=False,
158                above_weight_limit=False,
159                emergency=True,
160            ),
161            NOT_MOVE
162        )
163
164        self.assertEqual(
165            src.elevator.elevator(
166                doors_clear=False,
167                above_weight_limit=False,
168                number_pushed=False,
169                emergency=False,
170            ),
171            NOT_MOVE
172        )
173
174
175# Exceptions seen
176# AssertionError
177# NameError
178# AttributeError
179# TypeError

the code from elevator/src/elevator.py from Microwave

 1def elevator(
 2        doors_clear, number_pushed,
 3        above_weight_limit=False, emergency=False,
 4    ):
 5    if (
 6        emergency
 7        or above_weight_limit
 8        or not (
 9            doors_clear
10            and
11            number_pushed
12        )
13    ):
14        return 'NOT MOVE'
15
16    return 'MOVE'
17
18    not_move = 'NOT MOVE'
19
20    if emergency:
21        return not_move
22
23    if above_weight_limit:
24        return not_move
25
26    if not doors_clear:
27        return not_move
28
29    if not number_pushed:
30        return not_move
31
32    return 'MOVE'

Parking Garage: tests and solutions

the code from parking_garage/tests/test_parking_garage.py from ParkingGarage

1

the code from parking_garage/src/parking_garage.py from Microwave

1