truth table: tests and solutions

Nullary and Unary Operations tests

the code from truth_table/tests/test_binary.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(src.truth_table.logical_true())
 9
10    def test_logical_false(self):
11        self.assertFalse(src.truth_table.logical_false())
12
13
14class TestUnaryOperations(unittest.TestCase):
15
16    def test_logical_identity(self):
17        self.assertTrue(src.truth_table.logical_identity(True))
18        self.assertFalse(src.truth_table.logical_identity(False))
19
20    def test_logical_negation_aka_not(self):
21        self.assertFalse(src.truth_table.logical_negation(True))
22        self.assertTrue(src.truth_table.logical_negation(False))
23
24
25# Exceptions seen
26# AssertionError
27# AttributeError
28# TypeError

Binary Operations tests

the code from truth_table/tests/test_binary.py from truth table

  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(True, True)
 24        )
 25        self.assertFalse(
 26            src.truth_table.logical_conjunction(True, False)
 27        )
 28        self.assertFalse(
 29            src.truth_table.logical_conjunction(False, True)
 30        )
 31        self.assertFalse(
 32            src.truth_table.logical_conjunction(False, False)
 33        )
 34
 35    def test_project_second(self):
 36        self.assertTrue(
 37            src.truth_table.project_second(True, True)
 38        )
 39        self.assertFalse(
 40            src.truth_table.project_second(True, False)
 41        )
 42        self.assertTrue(
 43            src.truth_table.project_second(False, True)
 44        )
 45        self.assertFalse(
 46            src.truth_table.project_second(False, False)
 47        )
 48
 49    def test_converse_non_implication(self):
 50        self.assertFalse(
 51            src.truth_table.converse_non_implication(True, True)
 52        )
 53        self.assertFalse(
 54            src.truth_table.converse_non_implication(True, False)
 55        )
 56        self.assertTrue(
 57            src.truth_table.converse_non_implication(False, True)
 58        )
 59        self.assertFalse(
 60            src.truth_table.converse_non_implication(False, False)
 61        )
 62
 63    def test_negate_first(self):
 64        self.assertFalse(src.truth_table.negate_first(True, True))
 65        self.assertFalse(src.truth_table.negate_first(True, False))
 66        self.assertTrue(src.truth_table.negate_first(False, True))
 67        self.assertTrue(src.truth_table.negate_first(False, False))
 68
 69    def test_logical_nand(self):
 70        self.assertFalse(src.truth_table.logical_nand(True, True))
 71        self.assertTrue(src.truth_table.logical_nand(True, False))
 72        self.assertTrue(src.truth_table.logical_nand(False, True))
 73        self.assertTrue(src.truth_table.logical_nand(False, False))
 74
 75    def test_tautology(self):
 76        self.assertTrue(src.truth_table.tautology(True, True))
 77        self.assertTrue(src.truth_table.tautology(True, False))
 78        self.assertTrue(src.truth_table.tautology(False, True))
 79        self.assertTrue(src.truth_table.tautology(False, False))
 80
 81    def test_logical_disjunction(self):
 82        self.assertTrue(
 83            src.truth_table.logical_disjunction(True, True)
 84        )
 85        self.assertTrue(
 86            src.truth_table.logical_disjunction(True, False)
 87        )
 88        self.assertTrue(
 89            src.truth_table.logical_disjunction(False, True)
 90        )
 91        self.assertFalse(
 92            src.truth_table.logical_disjunction(False, False)
 93        )
 94
 95    def test_exclusive_disjunction(self):
 96        self.assertFalse(src.truth_table.exclusive_disjunction(True, True))
 97        self.assertTrue(src.truth_table.exclusive_disjunction(True, False))
 98        self.assertTrue(src.truth_table.exclusive_disjunction(False, True))
 99        self.assertFalse(src.truth_table.exclusive_disjunction(False, False))
100
101    def test_material_non_implication(self):
102        self.assertFalse(
103            src.truth_table.material_non_implication(True, True)
104        )
105        self.assertTrue(
106            src.truth_table.material_non_implication(True, False)
107        )
108        self.assertFalse(
109            src.truth_table.material_non_implication(False, True)
110        )
111        self.assertFalse(
112            src.truth_table.material_non_implication(False, False)
113        )
114
115    def test_project_first(self):
116        self.assertTrue(src.truth_table.project_first(True, True))
117        self.assertTrue(src.truth_table.project_first(True, False))
118        self.assertFalse(src.truth_table.project_first(False, True))
119        self.assertFalse(src.truth_table.project_first(False, False))
120
121    def test_converse_implication(self):
122        self.assertTrue(src.truth_table.converse_implication(True, True))
123        self.assertTrue(src.truth_table.converse_implication(True, False))
124        self.assertFalse(src.truth_table.converse_implication(False, True))
125        self.assertTrue(src.truth_table.converse_implication(False, False))
126
127    def test_negate_second(self):
128        self.assertFalse(src.truth_table.negate_second(True, True))
129        self.assertTrue(src.truth_table.negate_second(True, False))
130        self.assertFalse(src.truth_table.negate_second(False, True))
131        self.assertTrue(src.truth_table.negate_second(False, False))
132
133    def test_logical_nor(self):
134        self.assertFalse(src.truth_table.logical_nor(True, True))
135        self.assertFalse(src.truth_table.logical_nor(True, False))
136        self.assertFalse(src.truth_table.logical_nor(False, True))
137        self.assertTrue(src.truth_table.logical_nor(False, False))
138
139    def test_logical_equality(self):
140        self.assertTrue(src.truth_table.logical_equality(True, True))
141        self.assertFalse(src.truth_table.logical_equality(True, False))
142        self.assertFalse(src.truth_table.logical_equality(False, True))
143        self.assertTrue(src.truth_table.logical_equality(False, False))
144
145    def test_material_implication(self):
146        self.assertTrue(src.truth_table.material_implication(True, True))
147        self.assertFalse(src.truth_table.material_implication(True, False))
148        self.assertTrue(src.truth_table.material_implication(False, True))
149        self.assertTrue(src.truth_table.material_implication(False, False))
150
151
152# Exceptions seen
153# AttributeError
154# TypeError
155# AssertionError
156# SyntaxError

Booleans 2 tests

the code from booleans/tests/test_booleans.py from booleans 2: test with bool

 1import unittest
 2
 3
 4class TestBooleans(unittest.TestCase):
 5
 6    def test_what_is_false(self):
 7        self.assertIsInstance(False, bool)
 8        self.assertFalse(False)
 9        self.assertFalse(None)
10        self.assertFalse(bool(None))
11        self.assertFalse(0)
12        self.assertFalse(bool(0))
13        self.assertFalse(0.0)
14        self.assertFalse(bool(0.0))
15        self.assertFalse(str())
16        self.assertFalse(bool(str()))
17        self.assertFalse(tuple())
18        self.assertFalse(bool(tuple()))
19        self.assertFalse(list())
20        self.assertFalse(bool(list()))
21        self.assertFalse(set())
22        self.assertFalse(bool(set()))
23        self.assertFalse(dict())
24        self.assertFalse(bool(dict()))
25
26    def test_what_is_true(self):
27        self.assertIsInstance(True, bool)
28        self.assertTrue(True)
29        self.assertTrue(-1)
30        self.assertTrue(bool(-1))
31        self.assertTrue(1)
32        self.assertTrue(bool(1))
33        self.assertTrue(-0.1)
34        self.assertTrue(bool(-0.1))
35        self.assertTrue(0.1)
36        self.assertTrue(bool(0.1))
37        self.assertTrue("text")
38        self.assertTrue(bool("text"))
39        self.assertTrue((1, 2, 3, 'n'))
40        self.assertTrue(bool((1, 2, 3, 'n')))
41        self.assertTrue([1, 2, 3, 'n'])
42        self.assertTrue(bool([1, 2, 3, 'n']))
43        self.assertTrue({1, 2, 3, 'n'})
44        self.assertTrue(bool({1, 2, 3, 'n'}))
45        self.assertTrue({'key': 'value'})
46        self.assertTrue(bool({'key': 'value'}))
47
48
49# NOTES
50# a dictionary with things is True
51# a set with things is True
52# a list with things is True
53# a tuple with things is True
54# a string with things is True
55# positive and negative numbers are True
56# True is True
57# True is not false
58# True is a boolean
59# the empty dictionary is False
60# the empty set is False
61# the empty list is False
62# the empty tuple is False
63# the empty string is False
64# 0 is False
65# None is False
66# False is False
67# False is not true
68# False is a boolean
69
70
71# Exceptions seen
72# AssertionError

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 not first_input and second_input
31
32
33def negate_first(first_input, second_input):
34    return not first_input
35
36
37def logical_nand(first_input, second_input):
38    return not (first_input and second_input)
39
40
41def tautology(first_input, second_input):
42    return True
43
44
45def logical_disjunction(first_input, second_input):
46    return first_input or second_input
47
48
49def exclusive_disjunction(first_input, second_input):
50    return first_input != second_input
51    return not first_input == second_input
52    return (
53        (not first_input and second_input)
54        or
55        (first_input and not second_input)
56    )
57
58
59def material_non_implication(first_input, second_input):
60    return first_input and not second_input
61
62
63def project_first(first_input, second_input):
64    return first_input
65
66
67def converse_implication(first_input, second_input):
68    return first_input or not second_input
69
70
71def negate_second(first_input, second_input):
72    return not second_input
73
74
75def logical_nor(first_input, second_input):
76    return not (first_input or second_input)
77
78
79def logical_equality(first_input, second_input):
80    return first_input == second_input
81    return (
82        (first_input or not second_input)
83        and
84        (not first_input or second_input)
85    )
86
87
88def material_implication(first_input, second_input):
89    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_withdraw_w_not_expired_card_w_right_pin(self):
 11        self.assertEqual(
 12            src.atm.withdraw(
 13                card_expired=False,
 14                pin_is_right=True,
 15                enough_balance=True,
 16                above_daily_limit=False,
 17            ),
 18            'CASH'
 19        )
 20
 21        self.assertEqual(
 22            src.atm.withdraw(
 23                card_expired=False,
 24                pin_is_right=True,
 25                enough_balance=True,
 26                above_daily_limit=True,
 27            ),
 28            DENIED
 29        )
 30
 31        self.assertEqual(
 32            src.atm.withdraw(
 33                card_expired=False,
 34                pin_is_right=True,
 35                enough_balance=False,
 36                above_daily_limit=True,
 37            ),
 38            DENIED
 39        )
 40
 41        self.assertEqual(
 42            src.atm.withdraw(
 43                card_expired=False,
 44                pin_is_right=True,
 45                enough_balance=False,
 46                above_daily_limit=False,
 47            ),
 48            DENIED
 49        )
 50
 51    def test_withdraw_w_expired_card_w_right_pin(self):
 52        self.assertEqual(
 53            src.atm.withdraw(
 54                card_expired=True,
 55                pin_is_right=True,
 56                enough_balance=True,
 57                above_daily_limit=True,
 58            ),
 59            DENIED
 60        )
 61
 62        self.assertEqual(
 63            src.atm.withdraw(
 64                card_expired=True,
 65                pin_is_right=True,
 66                enough_balance=True,
 67                above_daily_limit=False,
 68            ),
 69            DENIED
 70        )
 71
 72        self.assertEqual(
 73            src.atm.withdraw(
 74                card_expired=True,
 75                pin_is_right=True,
 76                enough_balance=False,
 77                above_daily_limit=True,
 78            ),
 79            DENIED
 80        )
 81
 82        self.assertEqual(
 83            src.atm.withdraw(
 84                card_expired=True,
 85                pin_is_right=True,
 86                enough_balance=False,
 87                above_daily_limit=False,
 88            ),
 89            DENIED
 90        )
 91
 92    def test_withdraw_w_expired_card_w_wrong_pin(self):
 93        self.assertEqual(
 94            src.atm.withdraw(
 95                card_expired=True,
 96                pin_is_right=False,
 97                enough_balance=True,
 98                above_daily_limit=True,
 99            ),
100            DENIED
101        )
102
103        self.assertEqual(
104            src.atm.withdraw(
105                card_expired=True,
106                pin_is_right=False,
107                enough_balance=True,
108                above_daily_limit=False,
109            ),
110            DENIED
111        )
112
113        self.assertEqual(
114            src.atm.withdraw(
115                card_expired=True,
116                pin_is_right=False,
117                enough_balance=False,
118                above_daily_limit=True,
119            ),
120            DENIED
121        )
122
123        self.assertEqual(
124            src.atm.withdraw(
125                card_expired=True,
126                pin_is_right=False,
127                enough_balance=False,
128                above_daily_limit=False,
129            ),
130            DENIED
131        )
132
133    def test_withdraw_w_not_expired_card_w_wrong_pin(self):
134        self.assertEqual(
135            src.atm.withdraw(
136                card_expired=False,
137                pin_is_right=False,
138                enough_balance=True,
139                above_daily_limit=True,
140            ),
141            DENIED
142        )
143
144        self.assertEqual(
145            src.atm.withdraw(
146                card_expired=False,
147                pin_is_right=False,
148                enough_balance=True,
149                above_daily_limit=False,
150            ),
151            DENIED
152        )
153
154        self.assertEqual(
155            src.atm.withdraw(
156                card_expired=False,
157                pin_is_right=False,
158                enough_balance=False,
159                above_daily_limit=True,
160            ),
161            DENIED
162        )
163
164        self.assertEqual(
165            src.atm.withdraw(
166                card_expired=False,
167                pin_is_right=False,
168                enough_balance=False,
169                above_daily_limit=False,
170            ),
171            DENIED
172        )
173
174
175# Exceptions seen
176# AssertionError
177# NameError
178# AttributeError
179# TypeError

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

 1def withdraw(
 2        pin_is_right, enough_balance,
 3        above_daily_limit=False, card_expired=False,
 4    ):
 5    denied = 'DENIED'
 6
 7    if (
 8        not card_expired and pin_is_right
 9        and enough_balance and not above_daily_limit
10    ):
11        return 'CASH'
12    return denied
13
14    if card_expired:
15        return denied
16    if not pin_is_right:
17        return denied
18    if not enough_balance:
19        return denied
20    if above_daily_limit:
21        return denied
22
23    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

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'