truth table: Nullary and Unary Operations¶

requirements¶

I open a terminal to run makePythonTdd.sh with truth_table as the name of the project
```
./makePythonTdd.sh truth_table
```
on Windows without Windows Subsystem for Linux use makePythonTdd.ps1 instead of makePythonTdd.sh
```
./makePythonTdd.ps1 truth_table
```
it makes the folders and files that are needed, installs packages, runs the first test, and the terminal shows AssertionError
```
E       AssertionError: True is not false

tests/test_truth_table.py:7: AssertionError
```
I hold ctrl (Windows/Linux) or option or command (MacOS) on the keyboard and use the mouse to click on tests/test_truth_table.py:7 to open it in the editor
then I change True to False to make the test pass
```
7        self.assertFalse(False)
```

Nullary Operations¶

There are 2 Nullary operations, they do not take input and always return the same value

Logical True
Logical False

test_logical_true¶

RED: make it fail¶

I change the text in test_truth_table.py

import unittest
import src.truth_table

class TestNullaryOperations(unittest.TestCase):

    def test_logical_true(self):
        self.assertTrue(src.truth_table.logical_true())

# Exceptions Encountered

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_true'

GREEN: make it pass¶

I add it to the list of Exceptions encountered in test_truth_table.py

# Exceptions Encountered
# AssertionError
# AttributeError

I click on truth_table.py in the src folder to open it in the editor, then I add a function
```
1def logical_true():
2    return None
```
the terminal shows AssertionError
```
AssertionError: None is not true
```
I change False to True in the return statement
```
1def logical_true():
2    return True
```
the test passes

test_logical_false¶

RED: make it fail¶

I add another test to test_truth_table.py

    def test_logical_true(self):
        self.assertTrue(src.truth_table.logical_true())

    def test_logical_false(self):
        self.assertFalse(src.truth_table.logical_false())


# Exceptions Encountered

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_false'. Did you mean: 'logical_true'?

GREEN: make it pass¶

I add a function definition to truth_table.py

def logical_true():
    return True


def logical_false():
    return True

the terminal shows AssertionError

AssertionError: True is not false

I change True to False in the return statement
```
5def logical_false():
6    return False
```
the test passes

Unary Operations¶

There are 2 unary operations, they each take one input

Logical Identity
Logical Negation

test_logical_identity¶

RED: make it fail¶

I add a new TestCase and a test to test_truth_table.py

    def test_logical_false(self):
        self.assertFalse(src.truth_table.logical_false())

class TestUnaryOperations(unittest.TestCase):

    def test_logical_identity(self):
        self.assertTrue(src.truth_table.logical_identity(True))

# Exceptions Encountered

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_identity'

GREEN: make it pass¶

I add the function to truth_table.py

def logical_false():
    return False


def logical_identity():
    return False

the terminal shows TypeError

TypeError: logical_identity() takes 0 positional arguments but 1 was given

I add the error to the list of Exceptions encountered in test_truth_table.py

# Exceptions Encountered
# AssertionError
# AttributeError
# TypeError

I add a name in parentheses for logical_identity to take input in truth_table.py

def logical_identity(the_input):
    return False

the terminal shows AssertionError

AssertionError: False is not true

I change the return statement

def logical_identity(the_input):
    return True

the test passes

REFACTOR: make it better¶

I add another line to test_logical_identity in test_truth_table.py

    def test_logical_identity(self):
        self.assertTrue(src.truth_table.logical_identity(True))
        self.assertFalse(src.truth_table.logical_identity(False))

the terminal shows AssertionError

AssertionError: True is not false

I change the return statement of logical_identity in truth_table.py
```
 9def logical_identity(the_input):
10    return False
```
the terminal shows AssertionError
```
AssertionError: False is not true
```
there is a failure for the test that passed before. The expectation of the test is that when True is given, the result is True and when False is given, the result is False
I change the return statement of the function
```
 9def logical_identity(the_input):
10    return the_input
```
the test passes. logical_identity returns its input as output.

test_logical_negation¶

RED: make it fail¶

I add a new test to test_truth_table.py

    def test_logical_identity(self):
        self.assertTrue(src.truth_table.logical_identity(True))
        self.assertFalse(src.truth_table.logical_identity(False))

    def test_logical_negation(self):
        self.assertFalse(src.truth_table.logical_negation(True))


# Exceptions Encountered

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_negation'

GREEN: make it pass¶

I add a definition for the function in truth_table.py

def logical_identity(the_input):
    return the_input


def logical_negation(the_input):
    return the_input

the terminal shows AssertionError

AssertionError: True is not false

I change the return statement

def logical_negation(the_input):
    return False

the test passes

REFACTOR: make it better¶

I add another line in test_logical_negation in test_truth_table.py

    def test_logical_negation(self):
        self.assertFalse(src.truth_table.logical_negation(True))
        self.assertTrue(src.truth_table.logical_negation(False))

the terminal shows AssertionError

AssertionError: False is not true

I change the return statement of the logical_negation function in truth_table.py
```
13def logical_negation(the_input):
14    return True
```
the terminal shows AssertionError
```
AssertionError: True is not false
```
the test fails for the line that passed before
I make the function return its input
```
13def logical_negation(the_input):
14    return the_input
```
the terminal shows AssertionError
```
AssertionError: True is not false
```
the expectation of the test is that when True is given, the result is False and when False is given, the result is True, I can make that happen with the “not” keyword. I add it to the return statement
```
13def logical_negation(the_input):
14    return not the_input
```
the test passes. logical_negation returns the opposite of its input

I change the name of the test

class TestUnaryOperations(unittest.TestCase):

    def test_logical_identity(self):
        self.assertTrue(src.truth_table.logical_identity(True))
        self.assertFalse(src.truth_table.logical_identity(False))

    def test_logical_negation_aka_not(self):
        self.assertFalse(src.truth_table.logical_negation(True))
        self.assertTrue(src.truth_table.logical_negation(False))


# Exceptions Encountered

review¶

I ran the following tests for Nullary

test_logical_true
test_logical_false

and

for Unary operations

test_logical_identity
test_logical_negation

Would you like to test binary operations?

truth table: tests and solutions