class CalculatorTests(TestCase):
def setUp(self):
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
class CalculatorTests(TestCase):
"""Tests for calculator method"""
def setUp(self):
"""setup for calculator tests"""
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
"""error raised when only one number entered"""
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
"""tests adder method is called correctly"""
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
"""tests subtracter method is called correctly"""
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
def test_divider_call(self):
"""tests divider method is called correctly"""
self.divider.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.divide()
self.divider.calc.assert_called_with(1, 2)
def test_multiplier_call(self):
"""tests multiplier method is called correctly"""
self.multiplier.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.multiply()
self.multiplier.calc.assert_called_with(1, 2)
class CalculatorTests(TestCase):
"""Unit test for initiating the calculator"""
def setUp(self):
"""Initializes the calculator"""
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
"""Tests if there's sufficient operands"""
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
"""Test if the add functions adds in correct order"""
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
"""Test if the subtract functions adds in correct order"""
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
def test_multiplier_call(self):
"""Test if the multiply functions adds in correct order"""
self.multiplier.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.multiply()
self.multiplier.calc.assert_called_with(1, 2)
def test_divider_call(self):
"""Test if the divide functions adds in correct order"""
self.divider.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.divide()
self.divider.calc.assert_called_with(1, 2)
class CalculatorTests(TestCase):
def setUp(self):
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_multiplier(self):
lis = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
answers = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144]
index = 0
for nums in enumerate(lis, 1):
x, y = nums
self.calculator.enter_number(x)
self.calculator.enter_number(y)
result = self.calculator.multiply()
self.assertEqual(answers[index], result)
index += 1
def test_divider(self):
lis = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144]
answers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
index = 0
for nums in enumerate(lis, 1):
x, y = nums
self.calculator.enter_number(y)
self.calculator.enter_number(x)
result = self.calculator.divide()
self.assertEqual(answers[index], result)
index += 1
def test_insufficient_operands(self):
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
class CalculatorTests(TestCase):
def setUp(self):
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
# Numbers are inserted at index 0. Either switch this or switch the
# calc function call order.
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
def test_multiplier_call(self):
self.multiplier.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.multiply()
self.multiplier.calc.assert_called_with(1, 2)
def test_divider_call(self):
self.divider.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.divide()
self.divider.calc.assert_called_with(1, 2)
class CalculatorTests(TestCase):
"""
This class tests mocking
"""
def setUp(self):
"""
This method initializes variables
"""
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
"""
This method tests InsufficientOperands
"""
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
"""
This method tests mock adder
"""
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
"""
This method tests mock subtracter
"""
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
def test_module(self):
"""
Test the Adder, Subtracter, Multiplier, Divider classes and
the Calculator class concurrently.
"""
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)
class TestCalculator(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_add_given_two_values_should_return_the_correct_value(self):
result = self.calculator.add(10, 10)
self.assertEqual(first=result,
second=20,
msg='Invalid sum operation performed.')
def test_subtract_given_two_values_should_return_the_correct_value(self):
result = self.calculator.subtract(10, 10)
self.assertEqual(first=result,
second=0,
msg='Invalid subtract operation performed.')
def test_multiply_given_two_values_should_return_the_correct_value(self):
result = self.calculator.multiply(10, 10)
self.assertEqual(first=result,
second=100,
msg='Invalid multiply operation performed.')
def test_divide_given_two_values_should_return_the_correct_value(self):
result = self.calculator.divide(10, 10)
self.assertEqual(first=result,
second=1,
msg='Invalid divide operation performed.')
def test_module(self):
"""Test that a sequence of operations produces the expected result."""
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)
with self.assertRaises(InsufficientOperands):
calculator.add()
def test_module(self):
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
result = calculator.multiply()
self.assertEqual((2*5), result)
calculator.enter_number(46)
result = calculator.add()
self.assertEqual(result, (46+(2*5)))
calculator.enter_number(8)
result = calculator.divide()
self.assertEqual(result, (8 / (46+(2*5))))
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(result, (1 - (8 / (46+(2*5)))))
def test_module(self):
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
result_add = calculator.add()
self.assertEqual(56, result_add)
calculator.enter_number(8)
result_divide = calculator.divide()
self.assertEqual(7, result_divide)
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)
class ModuleTests(TestCase):
"""Test the calculator module/UI during random, sustained usage."""
def setUp(self):
self.calculator = Calculator(a(), s(), m(), d())
def test_module(self):
"""
Make sure the calculator returns the correct value after a
series of random number entries and operations.
"""
self.calculator.enter_number(5)
self.calculator.enter_number(2)
self.calculator.multiply()
self.calculator.enter_number(46)
self.calculator.add()
self.calculator.enter_number(8)
self.calculator.divide()
self.calculator.enter_number(1)
result = self.calculator.subtract()
self.assertEqual(6, result)
def test_after_division_by_zero(self):
"""
Make sure an insufficient operands exception occurs if a user
immediately invokes an operation after a division by zero error
without specifying another number. (Following a division by
zero, the stack is cleared, and only a zero is left there.)
"""
self.calculator.enter_number(15)
self.calculator.enter_number(5)
self.calculator.enter_number(0)
self.calculator.divide() # Div by 0 clears stack and pushes 0
with self.assertRaises(InsufficientOperands):
self.calculator.subtract()
self.calculator.enter_number(8)
result = self.calculator.subtract()
self.assertEqual(-8, result)
def test_module_insufficient_operands(self):
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
with self.assertRaises(InsufficientOperands):
calculator.subtract()
class CalculatorTests(TestCase):
def setUp(self):
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
self.adder.calc = MagicMock(return_value=(2 + 1))
self.calculator.enter_number(1)
self.calculator.enter_number(2)
result = self.calculator.add()
self.adder.calc.assert_called_with(2, 1)
self.assertEqual(result, (2 + 1))
def test_subtracter_call(self):
self.subtracter.calc = MagicMock(return_value=(2 - 1))
self.calculator.enter_number(1)
self.calculator.enter_number(2)
result = self.calculator.subtract()
self.subtracter.calc.assert_called_with(2, 1)
self.assertEqual(result, (2 - 1))
def test_multiplier_call(self):
self.multiplier.calc = MagicMock(return_value=(2 * 1))
self.calculator.enter_number(1)
self.calculator.enter_number(2)
result = self.calculator.multiply()
self.multiplier.calc.assert_called_with(2, 1)
self.assertEqual(result, (2 * 1))
def test_divider_call(self):
self.divider.calc = MagicMock(return_value=(2 / 1))
self.calculator.enter_number(1)
self.calculator.enter_number(2)
result = self.calculator.divide()
self.divider.calc.assert_called_with(2, 1)
self.assertEqual(result, (2 / 1))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
# Unit test 1
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
# Unit test 2
def test_subtraction(self):
test_data = CsvReader( BASE_DIR + "/data/UnitTestSubtraction.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.subtract(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
# Unit test 3
def test_addition(self):
test_data = CsvReader(BASE_DIR + "/data/UnitTestAddition.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.add(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
# Unit test 4
def test_multiplication(self):
test_data = CsvReader(BASE_DIR + "/data/UnitTestMultiplication.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.multiply(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
# Unit test 5
def test_division(self):
test_data = CsvReader(BASE_DIR + "/data/UnitTestDivision.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(round(self.calculator.divide(row['Value 1'], row['Value 2'])), round(result))
self.assertEqual(round(self.calculator.result), round(result))
# Unit test 6
def test_square(self):
test_data = CsvReader(BASE_DIR + "/data/UnitTestSquare.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.square(row['Value 1']), result)
self.assertEqual(self.calculator.result, result)
# Unit test 7
def test_square_root(self):
test_data = CsvReader(BASE_DIR + "/data/UnitTestSquareRoot.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(round(self.calculator.squareroot(row['Value 1'])), round(result))
self.assertEqual(round(self.calculator.result), round(result))
def test_module_zero_division_error(self):
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.subtract()
calculator.enter_number(0)
with self.assertRaises(ZeroDivisionError):
calculator.divide()
class CalculatorTests(TestCase):
"""Contain tests for Calculator class."""
def setUp(self):
"""Initialize calculator with new operator objects."""
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
"""Test Insufficient Operands exception."""
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
"""Test a call to the Adder function using MagicMock."""
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(2, 1)
def test_subtracter_call(self):
"""Test a call to the Divider function using MagicMock."""
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(2, 1)
class CalculatorTests(TestCase):
"""Series of Calculator Tests"""
def setUp(self):
"""Test case that setups the other test cases from range -10 to 10"""
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
"""Test insufficient operands"""
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
"""Test Case Adds Two Numbers"""
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
"""Test Case Subtracts Two Numbers"""
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
def test_module(self):
"""
Testing the calculator by calling each methods
"""
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)
class CalculatorTests(TestCase):
"""various test"""
def setUp(self):
"""Set up for calc tests so don't have to rewrite"""
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
# Line is too long, but whatever.
self.calculator = Calculator(self.adder, self.subtracter, self.multiplier, self.divider)
def test_insufficient_operands(self):
"""Will it raise an error when there aren't enough operands?"""
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
"""Does adder call adder in the right order?"""
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
"""Does subtractor call subtractor in the right order?"""
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
def test_module(self):
'''Runs the actual integration test, going through all calculator calls
and testing the end result'''
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
assert result == 6
class CalculatorTests(TestCase):
def setUp(self):
self.adder = Adder()
self.subtracter = Subtracter()
self.multiplier = Multiplier()
self.divider = Divider()
self.calculator = Calculator(self.adder, self.subtracter,
self.multiplier, self.divider)
def test_insufficient_operands(self):
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
# Why we use Mock here?
# Instead of calling adder, we are going to pretend, so we are tesing
# the code that is actually in the calculator
self.adder.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.add()
self.adder.calc.assert_called_with(1, 2)
def test_subtracter_call(self):
self.subtracter.calc = MagicMock(return_value=0)
self.calculator.enter_number(1)
self.calculator.enter_number(2)
self.calculator.subtract()
self.subtracter.calc.assert_called_with(1, 2)
def result():
first_term = request.form.get("first_term", type=int)
second_term = request.form.get("second_term", type=int)
operation = request.form.get("operation")
c = Calculator(first_term, second_term)
if operation == 'Add':
res = c.add()
elif operation == 'Subtract':
res = c.subtract()
elif operation == 'Multiply':
res = c.multiply()
elif operation == 'Divide':
res = c.divide()
else:
res = 'INVALID CHOICE'
return render_template('result.html', result=res)
def test_module(self):
"""The first of... one test module(s). lol lazy."""
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)
def test_module(self):
"Tests Addition, multiplication, subtraction, division" ""
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)
def test_module(self):
'''doc string'''
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(56)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(0, result)
def test_module(self):
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
# Tests
# Add:
self.assertEqual(7, calculator.add())
# Subtract:
calculator.enter_number(5)
self.assertEqual(2, calculator.subtract())
# Multiply:
calculator.enter_number(5)
self.assertEqual(10, calculator.multiply())
# Divide:
calculator.enter_number(1)
self.assertEqual(10, calculator.divide())
def test_module(self):
""" Tests each module against an expected output to ensure accuracy. """
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
# Tests
# Add:
self.assertEqual(7, calculator.add())
# Subtract:
calculator.enter_number(5)
self.assertEqual(2, calculator.subtract())
# Multiply:
calculator.enter_number(5)
self.assertEqual(10, calculator.multiply())
# Divide:
calculator.enter_number(1)
self.assertEqual(10, calculator.divide())
def test_module(self):
"""Tests all calculator modules."""
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply() #10
calculator.enter_number(46)
calculator.add() #56
calculator.enter_number(8)
calculator.divide() #7
calculator.enter_number(1)
result = calculator.subtract() #6
self.assertEqual(6, result) #Result should equal 6
def test_module(self):
"""Test that calculator performs operations as expected"""
calculator = Calculator(Adder(), Subtracter(), Multiplier(), Divider())
calculator.enter_number(5)
calculator.enter_number(2)
calculator.multiply()
calculator.enter_number(46)
calculator.add()
calculator.enter_number(8)
calculator.divide()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)