how to make a calculator

I want to write a program that can add, subtract, multiply and divide

preview

Here are the tests I have by the end of the chapter

import random
import src.calculator
import unittest


def a_random_number():
    return random.triangular(-10, 10)


class TestCalculator(unittest.TestCase):

    random_first_number = a_random_number()
    random_second_number = a_random_number()

    def test_addition(self):
        self.assertEqual(
            src.calculator.add(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number+self.random_second_number
        )

    def test_subtraction(self):
        self.assertEqual(
            src.calculator.subtract(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number-self.random_second_number
        )

    def test_multiplication(self):
        self.assertEqual(
            src.calculator.multiply(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number*self.random_second_number
        )

    def test_division(self):
        self.assertEqual(
            src.calculator.divide(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number/self.random_second_number
        )


# Exceptions seen
# AssertionError
# NameError
# AttributeError
# TypeError

start the project

I name this project calculator
I open a terminal
then I make a directory for the project
```
mkdir calculator
```
the terminal goes back to the command line
```
.../pumping_python
```
I change directory to the project
```
cd calculator
```
the terminal shows I am now in the calculator folder
```
.../pumping_python/calculator
```
I make a folder for the source code
```
mkdir src
```
the terminal goes back to the command line
```
.../pumping_python/calculator
```
I use touch to make an empty file for the program in the src folder
```
touch src/calculator.py
```
on Windows without Windows Subsystem for Linux use New-Item src/calculator.py instead of touch src/calculator.py
```
New-Item src/calculator.py
```
the terminal goes back to the command line
```
.../pumping_python/calculator
```
I make a directory for the tests
```
mkdir tests
```
the terminal goes back to the command line
I use touch to make an empty file in the tests folder to tell Python that it is a Python package

Attention

use 2 underscores (__) before and after init for __init__.py not _init_.py
```
touch tests/__init__.py
```
on Windows without Windows Subsystem for Linux use New-Item tests/__init__.py instead of touch tests/__init__.py
```
New-Item tests/__init__.py
```
the terminal goes back to the command line
I make an empty file for the actual test
```
touch tests/test_calculator.py
```
on Windows without Windows Subsystem for Linux use New-Item tests/test_calculator.py instead of touch tests/test_calculator.py
```
New-Item tests/test_calculator.py
```
the terminal goes back to the command line
I open test_calculator.py in the editor of the Integrated Development Environment (IDE)
Tip

I can open a file from the terminal in Visual Studio Code by typing code and the name of the file with
```
code tests/test_calculator.py
```
test_calculator.py opens up in the editor

I add the first failing test to test_calculator.py

import unittest

class TestCalculator(unittest.TestCase):

    def test_failure(self):
        self.assertFalse(True)

I make a virtual environment in the terminal
```
python3 -m venv .venv
```
on Windows without Windows Subsystem for Linux use python3 -m venv .venv instead of python3 -m venv .venv
```
python -m venv .venv
```
the terminal takes some time then goes back to the command line
I activate the virtual environment
```
source .venv/bin/activate
```
on Windows without Windows Subsystem for Linux use .venv/bin/activate.ps1 instead of source .venv/bin/activate
```
.venv/scripts/activate.ps1
```
the terminal shows
```
(.venv) .../pumping_python/calculator
```
I upgrade the Python package manager (pip) to the latest version
```
python3 -m pip install --upgrade pip
```
the terminal shows pip being uninstalled then installs the latest version or shows that it is already the latest version
I make a requirements.txt file for the Python programs my project needs
```
echo "pytest-watch" > requirements.txt
```
the terminal goes back to the command line
I use pip to use the requirements file to install pytest-watch
```
python3 -m pip install --requirement requirements.txt
```
on Windows without Windows Subsystem for Linux use python -m pip install --requirement requirements.txt instead of python3 -m pip install --requirement requirements.txt
```
python -m pip install --requirement requirements.txt
```
the terminal shows pip downloads and installs the Python programs that pytest-watch needs to run

I use pytest-watch to run the test

pytest-watch

the terminal shows

================================ FAILURES ================================
_____________________ TestCalculator.test_failure ________________________

self = <tests.test_calculator.TestCalculator testMethod=test_failure>

    def test_failure(self):
>       self.assertFalse(True)
E       AssertionError: True is not false

tests/test_calculator.py:7: AssertionError
======================== short test summary info =========================
FAILED tests/test_calculator.py::TestCalculator::test_failure - AssertionError: True is not false
=========================== 1 failed in X.YZs ============================

I hold ctrl (Windows/Linux) or option or command (MacOS) on the keyboard and use the mouse to click on tests/test_calculator.py:7 to open it in the editor

I add AssertionError to the list of Exceptions seen in test_calculator.py

        self.assertFalse(True)


# Exceptions seen
# AssertionError

then I change True to False in the assertion
```
7        self.assertFalse(False)
```
the test passes

I add a TODO list to keep track of the work for the program

import unittest


class TestCalculator(unittest.TestCase):

    def test_failure(self):
        self.assertFalse(False)


# TODO
# test addition
# test subtraction
# test multiplication
# test division


# Exceptions seen
# AssertionError

test_addition

RED: make it fail

I change test_failure to test_addition then change assertFalse to assertEqual
```
 1import unittest
 2
 3
 4class TestCalculator(unittest.TestCase):
 5
 6    def test_addition(self):
 7        self.assertEqual(
 8            src.calculator.add(0, 1),
 9            1
10        )
```
- the assertEqual method from AssertionError checks if the 2 things in parentheses are the same. It is like the statement assert x == y or asking is x equal to y?
- the explanation I like from what I have seen is that one of them is
  - reality - src.calculator.add(0, 1), and the other is
  - my expectation - 1, because 0 + 1 is 1
the terminal shows NameError
```
NameError: name 'src' is not defined
```
because src is not defined in test_calculator.py

GREEN: make it pass

I add NameError to the list of Exceptions seen in test_calculator.py
```
20# Exceptions seen
21# AssertionError
22# NameError
```
I add an import statement at the top of the file for the calculator module
```
1import src.calculator
2import unittest
3
4
5class TestCalculator(unittest.TestCase):
```
the terminal shows AttributeError
```
AttributeError: module 'src.calculator' has no attribute 'add'
```
I think of src.calculator.add as an address, add is something (an attribute) in the empty calculator.py file from the src folder (directory)

I add AttributeError to the list of Exceptions seen in test_calculator.py

# Exceptions seen
# AssertionError
# NameError
# AttributeError

I open calculator.py from the src folder in the editor, and I type the name
```
1add
```
the terminal shows NameError
```
NameError: name 'add' is not defined
```
I have to tell Python what the name add stands for or means
I point it to None
```
1add = None
```
the terminal shows TypeError
```
TypeError: 'NoneType' object is not callable
```
because the add variable is now a name for None which I cannot use like a function

I add TypeError to the list of Exceptions seen in test_calculator.py

# Exceptions seen
# AssertionError
# NameError
# AttributeError
# TypeError

I use the def keyword in calculator.py to make add a function so it is callable
```
1def add():
2    return None
```
the terminal shows TypeError
```
TypeError: add() takes 0 positional arguments but 2 were given
```
the definition of add does not allow it take input, but 2 were given in the call src.calculator.add(0, 1): 0 and 1
I make the add function take 2 inputs
```
1def add(first_input, second_input):
2    return None
```
the terminal shows AssertionError
```
AssertionError: None != 1
```
the add function returns None, the test expects 1
I make the return statement match the expected value
```
1def add(first_input, second_input):
2    return 1
```
the test passes, time for a victory lap!

REFACTOR: make it better

The add function passes the test but does not meet the actual requirement because it always returns 1. I want it to return the result of a calculation with the inputs

RED: make it fail

To show the problem with the function, I add another assertion in test_calculator.py

      def test_addition(self):
          self.assertEqual(
              src.calculator.add(0, 1),
              1
          )
          self.assertEqual(
              src.calculator.add(0, 2),
              2
          )

the terminal shows AssertionError

E    AssertionError: 1 != 2

the function returns 1, the test expects 2

GREEN: make it pass

when I change the return statement in calculator.py to match the expectation
```
1def add(first_input, second_input):
2    return 2
```
the terminal shows AssertionError
```
AssertionError: 2 != 1
```
this makes the assertion that was passing before now fail. I need a solution that can make the two tests pass
I make the function return the result of adding the two inputs
```
1def add(first_input, second_input):
2    return first_input + second_input
```
the test passes. The add function passes the two tests

RED: make it fail

I add another test to make sure the function works for other numbers

        self.assertEqual(
            src.calculator.add(0, 2),
            2
        )
        self.assertEqual(
            src.calculator.add(0, 3),
            2
        )

the terminal shows AssertionError

AssertionError: 3 != 2

GREEN: make it pass

I change the expectation in the test

        self.assertEqual(
            src.calculator.add(0, 3),
            3
        )

the test passes

RED: make it fail

I add another test with a different number for the first input

        self.assertEqual(
            src.calculator.add(0, 3),
            3
        )
        self.assertEqual(
            src.calculator.add(1, 3),
            3
        )

the terminal shows AssertionError

AssertionError: 4 != 3

GREEN: make it pass

I change the expectation to match reality

        self.assertEqual(
            src.calculator.add(1, 3),
            4
        )

the test passes. The add function looks good so far

RED: make it fail

I add a test with bigger numbers

        self.assertEqual(
            src.calculator.add(1, 3),
            4
        )
        self.assertEqual(
            src.calculator.add(123456, 789012),
            4
        )

the terminal shows AssertionError

AssertionError: 912468 != 4

GREEN: make it pass

I change the expectation to match reality

        self.assertEqual(
            src.calculator.add(123456, 789012),
            912468
        )

the test passes

RED: make it fail

I add another test, this time with a negative number

        self.assertEqual(
            src.calculator.add(123456, 789012),
            912468
        )
        self.assertEqual(
            src.calculator.add(-1, 0),
            912468
        )

the terminal shows AssertionError

AssertionError: -1 != 912468

GREEN: make it pass

I change the expectation to match reality

    self.assertEqual(
        src.calculator.add(-1, 0),
        -1
    )

the test passes

RED: make it fail

I try another test with two negative numbers

        self.assertEqual(
            src.calculator.add(-1, 0),
            -1
        )
        self.assertEqual(
            src.calculator.add(-2, -3),
            -1
        )

the terminal shows AssertionError

AssertionError: -5 != -1

GREEN: make it pass

I make the expectation match reality

        self.assertEqual(
            src.calculator.add(-2, -3),
            -5
        )

the test passes. The add function can handle positive and negative numbers

RED: make it fail

I add another test with floats (binary floating point decimal numbers)

          self.assertEqual(
              src.calculator.add(-2, -3),
              -5
          )
          self.assertEqual(
              src.calculator.add(0.1234, -5.6789),
              -5
          )

the terminal shows AssertionError

AssertionError: -5.555499999999999 != -5

GREEN: make it pass

I change the expectation

          self.assertEqual(
              src.calculator.add(0.1234, -5.6789),
              -5.555499999999999
          )

the test passes. Why is the result -5.555499999999999 instead of 5.5555?

what is a variable?

I just did the same kind of calculation 8 times in a row, there is a better way to this, you have seen this in Algebra. I can use a letter or a name for the numbers, that way I can have one test which covers all possible numbers. I can do this with a variable.

A variable is a name that is used for values that change. For example, in the tests so far, I have

src.calculator.add(0, 1) is 0+1 is 1
src.calculator.add(0, 2) is 0+2 is 2
src.calculator.add(0, 3) is 0+3 is 3
src.calculator.add(1, 3) is 1+3 is 4
src.calculator.add(123456, 789012) is 123456+789012 is 912468
src.calculator.add(-1, 0) is -1+0 is -1
src.calculator.add(-2, -3) is -2+-3 is -5
src.calculator.add(0.1234, -5.6789) is 0.1234+-5.6789 is -5.555499999999999

all of these lines can be written using first_number as the name of the first number and second_number as the name for the second number, like this

src.calculator.add(first_number, second_number) is first_number+second_number

I add a new test at the beginning of test_addition with names for the values

class TestCalculator(unittest.TestCase):

    def test_addition(self):
        self.assertEqual(
            src.calculator.add(first_number, second_number),
            first_number+second_number
        )
        self.assertEqual(
            src.calculator.add(0, 1),
            1
        )

the terminal shows NameError

NameError: name 'first_number' is not defined

I have to tell Python what the value of first_number is

I point first_number to 0 before the test

    def test_addition(self):
        first_number = 0

        self.assertEqual(
            src.calculator.add(first_number, second_number),
            first_number+second_number
        )

the terminal shows NameError

NameError: name 'second_number' is not defined

I have to tell Python what the value of second_number is

I point second_number to 1 before the test

    def test_addition(self):
        first_number = 0
        second_number = 1

        self.assertEqual(
            src.calculator.add(first_number, second_number),
            first_number+second_number
        )

the test passes

I remove the next test since it is now covered by this new assertion that uses a variable

    self.assertEqual(
        src.calculator.add(first_number, second_number),
        first_number+second_number
    )
    self.assertEqual(
        src.calculator.add(0, 2),
        2
    )

I can do the same thing for all the other tests by changing the values for first_input and second_input, for example

        first_number = 0
        second_number = 2

the test is still green

        first_number = 1
        second_number = 3

still green

        first_number = 123456
        second_number = 789012

the terminal still shows green

        first_number = 0.1234
        second_number = -5.6789

the test is still passing. The problem with this is I lose the test for the previous number, everytime I change a number. I need a better way

I want to use random numbers for first_input and second_input to make sure that the add function always returns the result of adding the two numbers without knowing what the numbers will be. I can do this with the random module from the Python standard library. I add an import statement for it at the top of test_calculator.py
```
1import random
2import src.calculator
3import unittest
```
random is a module from the Python standard library that is used to make fake random numbers

I use a random value for first_number

    def test_addition(self):
        # first_number = 0.1234
        first_number = random.triangular(-0.1, 1.0)
        second_number = -5.6789

the test is still green. random.triangular returns a random float that could be any number from -0.1 to 1.0 in this case

I want to see the test fail to be sure everything works as expected. I change the expectation in the first assertion
```
13        self.assertEqual(
14            src.calculator.add(first_number, second_number),
15            first_number+first_number
16        )
```
I hit save (ctrl+s (Windows/Linux) or command+s (mac)) a few times in the editor to run the tests and the terminal AssertionError with random values that look like this
```
AssertionError: -X.YZABCDEFGHIJKLM != A.BCDEFGHIJKLMNOPQ
```

I change the expectation of the assertion back to the right calculation

        self.assertEqual(
            src.calculator.add(first_number, second_number),
            first_number+second_number
        )

the test is green again

I remove the commented line then use a random value for second_number

    def test_addition(self):
        first_number = random.triangular(-0.1, 1.0)
        # second_number = -5.6789
        second_number = random.triangular(-0.1, 1.0)

the test is still green

I remove the commented line and the other assertions because they are covered by the one that uses random numbers. I do not need them anymore

    def test_addition(self):
        first_number = random.triangular(-0.1, 1.0)
        second_number = random.triangular(-0.1, 1.0)

        self.assertEqual(
            src.calculator.add(first_number, second_number),
            first_number+second_number
        )


# TODO

still green

I change the name of the variables to be more clear

def test_addition(self):
    random_first_number = random.triangular(-0.1, 1.0)
    random_second_number = random.triangular(-0.1, 1.0)

    self.assertEqual(
        src.calculator.add(
            random_first_number,
            random_second_number
        ),
        random_first_number+random_second_number
    )

the test is still green

There is some duplication, I have to make a change in more than one place when I want to use a different range of random numbers for the test, for example

    def test_addition(self):
        random_first_number = random.triangular(-10.0, 10.0)
        random_second_number = random.triangular(-10.0, 10.0)

the test is still green

I add a function to remove the repetition

import random
import src.calculator
import unittest


def a_random_number():
    return random.triangular(-10.0, 10.0)


class TestCalculator(unittest.TestCase):

then I use the new function to get random values for the random_first_number and random_second_number variables

    def test_addition(self):
        # random_first_number = random.triangular(-10.0, 10.0)
        random_first_number = a_random_number()
        # random_second_number = random.triangular(-10.0, 10.0)
        random_second_number = a_random_number()

the terminal still shows green

I remove the commented lines

    def test_addition(self):
        random_first_number = a_random_number()
        random_second_number = a_random_number()

I now only need to change the range of random numbers for the test in one place
```
6def a_random_number():
7    return random.triangular(-10000.0, 10000.0)
```
and the terminal still shows green
I can use any range of numbers the computer can handle, for example
```
6def a_random_number():
7    return random.triangular(-10.0**100000, 10.0**100000)
```
the terminal shows OverflowError
```
OverflowError: (34, 'Numerical result out of range')
```
because the numbers are too big to be used
- ** is the symbol for raise to the power (exponents)
- 10.0**100000 is how to write 10.0 raised to the power of 100,000
I make the range smaller
```
6def a_random_number():
7    return random.triangular(-1000.0, 1000.0)
```
the test is still green, though the test takes a little longer to run

then I remove test addition from the TODO list

# TODO
# test subtraction
# test multiplication
# test division

test_subtraction

RED: make it fail

I add a test for subtraction in test_calculator.py

    def test_addition(self):
        random_first_number = a_random_number()
        random_second_number = a_random_number()

        self.assertEqual(
            src.calculator.add(
                random_first_number,
                random_second_number
            ),
            random_first_number+random_second_number
        )

    def test_subtraction(self):
        random_first_number = a_random_number()
        random_second_number = a_random_number()

        self.assertEqual(
            src.calculator.subtract(
                random_first_number,
                random_second_number
            ),
            random_first_number-random_second_number
        )


# TODO

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'subtract'

calculator.py in the src folder does not have anything named subtract in it

GREEN: make it pass

I add the name to calculator.py

def add(first_input, second_input):
    return first_input + second_input


subtract

the terminal shows NameError

NameError: name 'subtract' is not defined

I point subtract to None

subtract = None

the terminal shows TypeError

TypeError: 'NoneType' object is not callable

I have seen this before

I change subtract to a function to make it callable

def subtract():
    return None

the terminal shows TypeError

TypeError: subtract() takes 0 positional arguments but 2 were given

I make subtract take inputs
```
5def subtract(first_input, second_input):
6    return None
```
I hit save (ctrl+s (Windows/Linux) or command+s (mac)) a few times in the editor to run the tests and the terminal shows AssertionError with random values that look like this

the terminal shows AssertionError
```
AssertionError: None != XYZ.ABCDEFGHIJKLMNOP
```
subtract returns None, the test expects random_first_number-random_second_number or first_input-second_input - the difference between the 2 numbers

I make the subtract function return the difference between the inputs

def subtract(first_input, second_input):
    return first_input - second_input

the test passes. SUCCESS!

REFACTOR: make it better

I have some duplication to remove, the code below happens twice in test_calculator.py
```
random_first_number = a_random_number()
random_second_number = a_random_number()
```
once in test_addition and again in test_subtraction

I add class attributes (variables) to remove the duplication and use the same numbers for both tests

class TestCalculator(unittest.TestCase):

    random_first_number = a_random_number()
    random_second_number = a_random_number()

    def test_addition(self):
        random_first_number = a_random_number()
        random_second_number = a_random_number()

I use the new class attributes in test_addition

    def test_addition(self):
        # random_first_number = a_random_number()
        random_first_number = self.random_first_number
        # random_second_number = a_random_number()
        random_second_number = self.random_second_number

        self.assertEqual(
            src.calculator.add(
                random_first_number,
                random_second_number
            ),
            random_first_number+random_second_number
        )

and in test_subtraction

    def test_subtraction(self):
        # random_first_number = a_random_number()
        random_first_number = self.random_first_number
        # random_second_number = a_random_number()
        random_second_number = self.random_second_number

        self.assertEqual(
            src.calculator.subtract(
                random_first_number,
                random_second_number
            ),
            random_first_number-random_second_number
        )

the terminal shows the tests are still passing. The random_first_number and random_second_number variables are made once as class attributes and used later in each test with self.random_first_number and self.random_second_number, the same way I use unittest.TestCase methods like assertEqual or assertFalse

I remove the commented lines in test_addition

    def test_addition(self):
        random_first_number = self.random_first_number
        random_second_number = self.random_second_number

and do the same thing in test_subtraction

    def test_subtraction(self):
        random_first_number = self.random_first_number
        random_second_number = self.random_second_number

I can use the class attributes directly in test_addition

        self.assertEqual(
            src.calculator.add(
                # random_first_number,
                self.random_first_number,
                # random_second_number
                self.random_second_number
            ),
            # random_first_number+random_second_number
            self.random_first_number+self.random_second_number
        )

the test is still green. I remove the commented lines

        self.assertEqual(
            src.calculator.add(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number+self.random_second_number
        )

I do the same thing in test_subtraction

        self.assertEqual(
            src.calculator.subtract(
                # random_first_number,
                self.random_first_number,
                # random_second_number
                self.random_second_number
            ),
            # random_first_number-random_second_number
            self.random_first_number-self.random_second_number
        )

the test is still passing. I remove the commented lines

        self.assertEqual(
            src.calculator.subtract(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number-self.random_second_number
        )

I remove the first_random_number and second_random_number variables from test_addition and test_subtraction because they are no longer used

class TestCalculator(unittest.TestCase):

    random_first_number = a_random_number()
    random_second_number = a_random_number()

    def test_addition(self):
        self.assertEqual(
            src.calculator.add(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number+self.random_second_number
        )

    def test_subtraction(self):
        self.assertEqual(
            src.calculator.subtract(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number-self.random_second_number
        )


# TODO

and the tests are still green!

I remove test subtraction from the TODO list

# TODO
# test multiplication
# test division


# Exceptions seen

test_multiplication

RED: make it fail

I add a failing test for multiplication in test_calculator.py

    def test_subtraction(self):
        self.assertEqual(
            src.calculator.subtract(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number-self.random_second_number
        )

    def test_multiplication(self):
        self.assertEqual(
            src.calculator.multiply(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number*self.random_second_number
        )


# TODO

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'multiply'

GREEN: make it pass

using what I know so far, I add a function to calculator.py

def subtract(first_input, second_input):
    return first_input - second_input


def multiply(first_input, second_input):
    return first_input * second_input

the test passes! I remove test_multiplication from the TODO list in test_calculator.py

# TODO
# test division


# Exceptions seen

* is the symbol for multiplication
** is the symbol for raise to the power (exponent)

test_division

RED: make it fail

Time for division. I add a new test to test_calculator.py

    def test_multiplication(self):
        self.assertEqual(
            src.calculator.multiply(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number*self.random_second_number
        )

    def test_division(self):
        self.assertEqual(
            src.calculator.divide(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number/self.random_second_number
        )


# TODO

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'divide'

GREEN: make it pass

I add a function to calculator.py

def multiply(first_input, second_input):
    return first_input * second_input


def divide(first_input, second_input):
    return first_input / second_input

the test passes

I remove the TODO list

    def test_division(self):
        self.assertEqual(
            src.calculator.divide(
                self.random_first_number,
                self.random_second_number
            ),
            self.random_first_number/self.random_second_number
        )


# Exceptions seen
# AssertionError
# NameError
# AttributeError
# TypeError
# ZeroDivisionError

test_calculator_tests

Since everything is green, I can write the program that makes the tests pass without looking at them

RED: make it fail

I close test_calculator.py
then delete all the text in calculator.py, the terminal shows 4 failures, I start with the last AttributeError
```
AttributeError: module 'src.calculator' has no attribute 'subtract'
```
What other Exceptions do you think are raised as I go along?

GREEN: make it pass

I add the name to calculator.py

1subtract

the terminal shows NameError

NameError: name 'subtract' is not defined

I point it to None

subtract = None

the terminal shows TypeError

TypeError: 'NoneType' object is not callable

I change subtract to a function

def subtract():
    return None

the terminal shows TypeError

TypeError: subtract() takes 0 positional arguments but 2 were given

I add positional arguments to the function

def subtract(first_input, second_input):
    return None

the terminal shows AssertionError with random numbers

AssertionError: None != XYZ.ABCDEFGHIJKLMN

I change the return statement to see the difference between the inputs and expected output, remember the identity function?
```
1def subtract(first_input, second_input):
2    return first_input, second_input
```
the terminal shows AssertionError with random numbers that look like this
```
AssertionError: (XYZ.ABCDEFGHIJKLMN, YZA.BCDEFGHIJKLMNO) != ZAB.CDEFGHIJKLMNOP
```
the name of the function is subtract and the test expects the difference between the 2 inputs

I make the return statement match the expectation

def subtract(first_input, second_input):
    return first_input - second_input

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'multiply'

I add a function

def subtract(first_input, second_input):
    return first_input - second_input


def multiply():
    return None

the terminal shows TypeError

TypeError: multiply() takes 0 positional arguments but 2 were given

I add 2 variables for the positional arguments

def multiply(first_input, second_input):
    return None

the terminal shows AssertionError

AssertionError: None != XY.ZABCDEFGHIJKLM

I change the return statement to see the difference between the inputs and the expected output, identity function again

def multiply(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError with random numbers that look like this

AssertionError: (XYZ.ABCDEFGHIJKLMNO, -YZA.BCDEFGHIJKLMNOPQ) != -ZAB.CDEFGHIJKLMNOPQR

I change it to the multiplication of the inputs to match the name of the function

def multiply(first_input, second_input):
    return first_input * second_input

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'divide'

I add another function

def multiply(first_input, second_input):
    return first_input * second_input


def divide(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError with random numbers that look like this

AssertionError: (-XYZ.ABCDEFGHIJKLMNO, YZA.BCDEFGHIJKLMNOPQ) != -ZAB.CDEFGHIJKLMNOPQR

when I change the return statement to match the expectation

def divide(first_input, second_input):
    return first_input / second_input

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'add'

the return statement of the last 3 functions matched their names, I do the same thing for the new one

def subtract(first_input, second_input):
    return first_input - second_input

def multiply(first_input, second_input):
    return first_input * second_input

def divide(first_input, second_input):
    return first_input / second_input

def add(first_input, second_input):
    return first_input + second_input

and all the tests are passing with no random failures, or are they?

close the project

I close the file(s) I have open in the editor(s)
I click in the terminal and exit the tests with ctrl+c on the keyboard
I deactivate the virtual environment
```
deactivate
```
the terminal goes back to the command line, (.venv) is no longer on the left side
```
.../pumping_python/calculator
```
I change directory to the parent of calculator
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory

review

I wrote the following tests for a program that can add, subtract, multiply and divide

test_addition
test_subtraction
test_multiplication
test_division

I also saw the following Exceptions

code from the chapter

Do you want to see all the CODE I typed in this chapter?

what is next?

you know a lot

There is a problem, I have done the same steps for each of the 8 chapters covered so far

I think I know how to make a Python Test Driven Development environment. I am going to write a program that will do all the steps for making a project for me, so I never have to do those steps again.

Would you like to know how to make a Python Test Driven Development environment automatically?

truth table: test_truth_table_tests

how to make a test driven development environment automatically