class CalculatorTestCase(unittest.TestCase):
"""Calculator acceptance test case."""
def setUp(self):
self.calculator = Calculator()
def step_I_have_powered_calculator_on(self):
r'I have powered calculator on'
self.calculator.on()
def step_I_enter_a_number_into_the_calculator(self, number):
r'I enter "(.+)" into the calculator' # match by regexp
self.calculator.push(int(number))
def step_I_press_add(self): # matched by method name
self.calculator.add()
def step_the_result_should_be_on_the_screen(self, number):
r'the result should be "{number}" on the screen' # match by format-like string
self.assertEqual(int(number), self.calculator.get_result())
def test_addition(self):
"""Addition feature."""
filename = os.path.join(os.path.dirname(__file__),
'calculator.feature')
run(filename, self, verbose=True)
class TestMyCalculator(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_initial_value(self):
self.assertEqual(0, self.calc.value)
def test_add(self):
self.calc.add(1, 3)
self.assertEqual(4, self.calc.value)
def test_substract(self):
self.calc.substract(2, 2)
self.assertEqual(0, self.calc.value)
def test_multiply(self):
self.calc.multiply(2, 3)
self.assertEqual(6, self.calc.value)
def test_divide(self):
self.calc.divide(6, 2)
self.assertEqual(3, self.calc.value)
# Solution: testing print with @patch
@patch('sys.stdout', new_callable=io.StringIO)
def test_divide_zero(self, mock_stdout):
self.calc.divide(3, 0)
self.assertEqual(mock_stdout.getvalue(),
'You can\'t divide by zero!\n')
class TestCalculator(unittest.TestCase):
@classmethod
def setUpClass(self):
print('Set up class')
self.calc = Calculator()
@classmethod
def tearDownClass(self):
print('Tear down class')
def test_add(self):
self.assertEqual(self.calc.add(2, 7), 9)
self.assertEqual(self.calc.add(-1, 1), 0)
print(self.calc.add(2, 7), "= 2+7")
print(self.calc.add(-2, 7), "= -2+7")
def test_subtract(self):
self.assertEqual(self.calc.subtract(10, 2), 8)
print("10-2 =", self.calc.subtract(10, 2))
self.assertEqual(self.calc.subtract(-10, 2), -12)
self.assertEqual(self.calc.subtract(-10, -2), -8)
def test_multiply(self):
self.assertEqual(self.calc.multiply(10, 2), 20)
print("10*2 =", self.calc.multiply(10, 2))
self.assertEqual(self.calc.multiply(-10, 2), -20)
self.assertEqual(self.calc.multiply(-10, -2), 20)
def test_divide(self):
self.assertEqual(self.calc.divide(10, 2), 5)
print("10/2 =", self.calc.divide(10, 2))
self.assertEqual(self.calc.divide(-10, 2), -5)
self.assertEqual(self.calc.divide(-10, -2), 5)
self.assertEqual(self.calc.divide(-10, 4), -2.5)
class CalculatorTestCase(unittest.TestCase):
""" Calculator acceptance test case. """
def setUp(self):
self.calculator = Calculator()
def step_I_have_powered_calculator_on(self):
r'I have powered calculator on'
self.calculator.on()
def step_I_enter_a_number_into_the_calculator(self, number):
r'I enter "(.+)" into the calculator' # match by regexp
self.calculator.push(int(number))
def step_I_press_add(self): # matched by method name
self.calculator.add()
def step_the_result_should_be_on_the_screen(self, number):
r'the result should be "{number}" on the screen' # match by format-like string
self.assertEqual(int(number), self.calculator.get_result())
def test_addition(self):
""" Addition feature """
filename = os.path.join(os.path.dirname(__file__), 'calculator.feature')
run(filename, self, verbose=True)
class TestCalculator(unittest.TestCase):
@classmethod
def setUpClass(self):
self.calc = Calculator()
@classmethod
def tearDownClass(self):
del self.calc
def test_add(self):
self.assertEqual(self.calc.add(2, 7), 9)
with self.assertRaises(TypeError):
self.calc.add("2", 7)
# Write test methods for subtract, multiply, and divide
def test_subtract(self):
self.assertEqual(self.calc.subtract(10, 3), 7)
with self.assertRaises(TypeError):
self.calc.subtract("2", 7)
def test_multiply(self):
self.assertEqual(self.calc.multiply(10, 3), 30)
with self.assertRaises(TypeError):
self.calc.multiply("2", 7)
def test_divide(self):
self.assertEqual(self.calc.divide(10, 2), 5)
with self.assertRaises(TypeError):
self.calc.divide("2", 7)
with self.assertRaises(ZeroDivisionError):
self.calc.divide(1, 0)
class Test_Calculator(unittest.TestCase):
@classmethod
def setUpClass(self):
self.my_calc = Calculator()
# ? What is this for?
@classmethod
def tearDownClass(self):
# print('tear down class')
def test_is_instance(self):
self.assertIsInstance(self.my_calc, Calculator)
def test_add(self):
self.assertEqual(self.my_calc.add(2, 7), 9)
self.assertEqual(self.my_calc.add(-2, 7), 5)
def test_subtract(self):
self.assertEqual(self.my_calc.subtract(10, 5), 5)
self.assertEqual(self.my_calc.subtract(10, -5), 15)
def test_multiply(self):
self.assertEqual(self.my_calc.multiply(2, 7), 14)
self.assertEqual(self.my_calc.multiply(-2, 7), -14)
def test_divide(self):
self.assertEqual(self.my_calc.divide(8, 4), 2)
self.assertEqual(self.my_calc.divide(8, -4), -2)
if __name__ == '__main__':
unittest.main()
def test_add_multiple_custom_separator_check_log(self, mock_write):
Calculator.add("//[#][%]\n1#2%3")
mock_write.assert_called_once_with(6)
mock_write.reset_mock()
Calculator.add("//[##][%%]\n1##2%%3")
mock_write.assert_called_once_with(6)
class TestsCalculator(unittest.TestCase):
def setUp(self):
"""
Se ejecuta siempre antes de cada test
"""
self.calculator = Calculator()
def tearDown(self):
"""
Se ejecuta siempre después de cada test
"""
self.calculator = None
def test_add_1_2(self):
result = self.calculator.add(1, 2) # 1 + 2 = 3
self.assertEqual(result, 3)
def test_add_5_5(self):
result = self.calculator.add(5, 5) # 5 + 5 = 10
self.assertEqual(result, 10)
def test_add_commutative_property(self):
result_a = self.calculator.add(3, 4)
result_b = self.calculator.add(4, 3)
self.assertEqual(result_a, result_b)
def test_subtract_1_6(self):
result = self.calculator.subtract(1, 6) # 1 - 6 = -5
self.assertEqual(result, -5)
def test_subtract_no_commutative_property(self):
result_a = self.calculator.subtract(1, 6)
result_b = self.calculator.subtract(6, 1)
self.assertNotEqual(result_a, result_b)
class TestCalculator(unittest.TestCase):
@classmethod
def setUpClass(self):
print('Set up class')
# Create an instance of the calculator that can be used in all tests
self.calc = Calculator()
num1 = 2
num2 = 6
@classmethod
def tearDownClass(self):
print('Tear down class')
def test_add(self):
result = self.calc.add(2, 7)
expected = 9
self.assertEqual(result, expected)
self.assertEqual(self.calc.add(2, 2), 4)
self.assertEqual(self.calc.add(self.num1, self.num2), 8)
# Write test methods for subtract, multiply, and divide
def test_subtract(self):
result = self.calc.subtract(7, 2)
expected = 5
self.assertEqual(result, expected)
self.assertEqual(self.calc.add(2, 2), 4)
class TestCalculator(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_can_create_calculator_object(self):
self.assertNotEqual(self.calculator, None)
def test_add(self):
self.assertEqual(6, self.calculator.add(4, 2))
self.assertEqual(0, self.calculator.add(-5, 5))
self.assertEqual(-5, self.calculator.add(-3, -2))
def test_subtract(self):
self.assertEqual(3, self.calculator.subtract(9, 6))
self.assertEqual(-3, self.calculator.subtract(-1, 2))
self.assertEqual(-3, self.calculator.subtract(-5, -2))
def test_multiply(self):
self.assertEqual(10, self.calculator.multiply(2, 5))
self.assertEqual(-3, self.calculator.multiply(-1, 3))
self.assertEqual(6, self.calculator.multiply(-3, -2))
def test_divide(self):
self.assertEqual(5, self.calculator.divide(25, 5))
self.assertEqual(-2, self.calculator.divide(-6, 3))
self.assertEqual(3, self.calculator.divide(-9, -3))
def test_add_superior_1000(self):
self.assertEqual(Calculator.add("2,1001"), 2)
self.assertEqual(Calculator.add("2,1000,3"), 1005)
self.assertEqual(
Calculator.add(",".join(map(str, range(1200)))),
1000 * 1001 / 2
)
def do_GET(self):
# ______________________________
# Initialization
self._set_response()
# ______________________________
# Parse URL to get parameters
cleanPath = ""
cleanPath = self.path
cleanPath = cleanPath.replace("/?", "")
params = urllib.parse.parse_qs(cleanPath)
# ______________________________
# Calculate result
calc = Calculator()
calc.add(int(params['a'][0]))
calc.add(int(params['b'][0]))
result = calc.getResult()
# ______________________________
# Write output
output = str("<html><head><title>TEST</title></head><body>Result: " +
str(result) + "</body></html>")
self.wfile.write(output.format(self.path).encode('utf-8'))
class CalculatorDocstringTestCase(unittest.TestCase):
"""Calculator acceptance test case."""
def test_addition(self):
"""Addition feature."""
run(
__file__,
self,
as_str=__doc__,
scenario="Subsequent additions",
verbose=True,
)
def setUp(self):
self.calculator = Calculator()
def step_I_have_powered_calculator_on(self):
r"I have powered calculator on"
self.calculator.on()
def step_I_enter_a_number_into_the_calculator(self, number):
r'I enter "(.+)" into the calculator' # match by regexp
self.calculator.push(int(number))
def step_I_press_add(self): # matched by method name
self.calculator.add()
def step_the_result_should_be_on_the_screen(self, number):
r'the result should be "{number}" on the screen' # match by format-like string
self.assertEqual(int(number), self.calculator.get_result())
def test1():
pricing_rules = [
dict(lead_code="b",
price=10,
bonus_rules=lambda qty, tot: 10 if qty > 5 else 0),
dict(lead_code="r",
price=5,
bonus_rules=lambda qty, tot: tot * 0.1 if qty > 8 else 0),
dict(lead_code="st", price=2.5)
]
calculator = Calculator(pricing_rules)
calculator.add("b")
calculator.add("b")
calculator.add("b")
calculator.add("b")
calculator.add("b")
calculator.add("b")
calculator.add("r")
calculator.add("r")
calculator.add("st")
total = calculator.total()
assert total == 82.5
print("test1 sucessfull total = ", total)
class CalculatorTest(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_add(self):
self.assertEqual(self.calculator.add(9, 10), 9 + 10)
def test_data_type(self):
self.assertEqual(self.calculator.add("e", 10), "Expected a number.")
def test_subtract(self):
self.assertEqual(self.calculator.subtract(15, 10), 15 - 10)
def test_multiply(self):
self.assertEqual(self.calculator.multiply(8, -2), 8 * -2)
def test_divide(self):
self.assertEqual(self.calculator.divide(9, 2), 9 / 2)
def test_divide_by_zero(self):
self.assertEqual(self.calculator.divide(9, 0), "Divide by zero error.")
def test_dec2bin(self):
self.assertEqual(self.calculator.dec2bin(34), 100010)
def tearDown(self):
self.calculator = None
def test_module(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()
calculator.enter_number(1)
result = calculator.subtract()
self.assertEqual(6, result)
# pulled from the unittest file, testing that there is not
# a missing operand
with self.assertRaises(InsufficientOperands):
calculator.add()
def main():
calc = Calculator()
while True:
inp = input(calc)
try:
if '+' in inp:
temp = inp.split('+')
calc.add(int(temp[-1]))
elif '-' in inp:
temp = inp.split('-')
calc.subtrack(int(temp[-1]))
elif '/' in inp:
temp = inp.split('/')
calc.divide(int(temp[-1]))
elif '*' in inp:
temp = inp.split('*')
calc.multiply(int(temp[-1]))
else:
pass
except ValueError as v:
print(v)
except OverflowError as v:
print(v)
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_width(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 CalculatorGetResultTestCase(unittest.TestCase):
"""Test :py:meth:`Calculator.get_result`."""
def setUp(self):
self.calculator = Calculator()
def test_should_return_result(self):
"""Scenario: addition result present."""
# Arrange
self.calculator.on()
self.calculator.push(50)
self.calculator.push(70)
self.calculator.add()
# Act
result = self.calculator.get_result()
# Assert
self.assertEqual(result, 120)
def test_should_return_last_entered_value_if_no_operation_run(self):
"""Scenario: last result."""
# Arrange
self.calculator.on()
self.calculator.push(50)
self.calculator.push(70)
# Act
result = self.calculator.get_result()
# Assert
self.assertEqual(result, 70)
def test_should_raise_exception_if_not_powered(self):
"""Scenario: not powered."""
# Act & Assert
self.assertRaises(CalculatorNotPoweredError, self.calculator.get_result)
class CalculatorAddTestCase(unittest.TestCase):
"""Test :py:meth:`Calculator.add`."""
def setUp(self):
self.calculator = Calculator()
def test_should_add_all_numbers_in_stack_if_powered(self):
"""Scenario: add all numbers."""
# Arrange
self.calculator.on()
self.calculator.push(50)
self.calculator.push(70)
# Act
self.calculator.add()
# Assert
self.assertEqual(self.calculator.get_result(), 120)
def test_should_raise_exception_if_not_powered(self):
"""Scenario: not powered."""
# Act & Assert
self.assertRaises(CalculatorNotPoweredError, self.calculator.add)
def test_should_return_0_if_empty_stack(self):
"""Scenario: empty stack."""
# Arrange
self.calculator.on()
# Act
self.calculator.add()
# Assert
self.assertEqual(self.calculator.get_result(), 0)
class CalculatorAddTestCase(unittest.TestCase):
"""Test :py:meth:`Calculator.add`."""
def setUp(self):
self.calculator = Calculator()
def test_should_add_all_numbers_in_stack_if_powered(self):
"""Scenario: add all numbers."""
# Arrange
self.calculator.on()
self.calculator.push(50)
self.calculator.push(70)
# Act
self.calculator.add()
# Assert
self.assertEqual(self.calculator.get_result(), 120)
def test_should_raise_exception_if_not_powered(self):
"""Scenario: not powered."""
# Act & Assert
self.assertRaises(CalculatorNotPoweredError, self.calculator.add)
def test_should_return_0_if_empty_stack(self):
"""Scenario: empty stack."""
# Arrange
self.calculator.on()
# Act
self.calculator.add()
# Assert
self.assertEqual(self.calculator.get_result(), 0)
class TestCalculator(unittest.TestCase):
@classmethod
def setUpClass(self):
print('Set up class')
self.calc = Calculator()
# Create an instance of the calculator that can be used in all tests
@classmethod
def tearDownClass(self):
print('Tear down class')
def test_add(self):
self.assertEqual(self.calc.add(2, 7), 9)
self.assertEqual(self.calc.add("a", "b"), "not a number")
def test_subtract(self):
self.assertEqual(self.calc.subtract(7, 2), 5)
self.assertEqual(self.calc.subtract("a", "b"), "not a number")
def test_mult(self):
self.assertEqual(self.calc.mult(7, 2), 14)
self.assertEqual(self.calc.mult("a", "b"), "not a number")
def test_div(self):
self.assertEqual(self.calc.div(6, 2), 3)
self.assertEqual(self.calc.div("a", "b"), "not a number")
class CalculatorGetResultTestCase(unittest.TestCase):
"""Test :py:meth:`Calculator.get_result`."""
def setUp(self):
self.calculator = Calculator()
def test_should_return_result(self):
"""Scenario: addition result present."""
# Arrange
self.calculator.on()
self.calculator.push(50)
self.calculator.push(70)
self.calculator.add()
# Act
result = self.calculator.get_result()
# Assert
self.assertEqual(result, 120)
def test_should_return_last_entered_value_if_no_operation_run(self):
"""Scenario: last result."""
# Arrange
self.calculator.on()
self.calculator.push(50)
self.calculator.push(70)
# Act
result = self.calculator.get_result()
# Assert
self.assertEqual(result, 70)
def test_should_raise_exception_if_not_powered(self):
"""Scenario: not powered."""
# Act & Assert
self.assertRaises(CalculatorNotPoweredError, self.calculator.get_result)
class TestCalculator(unittest.TestCase):
@classmethod
def setUpClass(self):
print('Set up class')
# Create an instance of the calculator that can be used in all tests
self.calc = Calculator()
@classmethod
def tearDownClass(self):
print('Tear down class')
def test_add(self):
self.assertEqual(self.calc.add(2, 7), 9)
print(self.calc.add(2,7))
# Write test methods for subtract, multiply, and divide
def test_subtract(self):
self.assertEqual(self.calc.subtract(10, 1), 9)
print(self.calc.subtract(10, 1))
def test_multiply(self):
self.assertEqual(self.calc.multiply(3, 3), 9)
print(self.calc.multiply(3, 3))
def test_divide(self):
self.assertEqual(self.calc.divide(18, 2), 9)
print(self.calc.divide(18, 2))
class CalculatorTests(TestCase):
"""Object to store calculator tests"""
def setUp(self):
"""Setup function to add modules to 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):
"""Function to raise exception if not enough
operands are entered"""
self.calculator.enter_number(0)
with self.assertRaises(InsufficientOperands):
self.calculator.add()
def test_adder_call(self):
"""Function to run through adder calls"""
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):
"""Function to run through subtracter calls"""
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):
"""Function to run through multiplier calls"""
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):
"""Function to run through divider calls"""
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_add_type_error():
#Sometimes useful to test whether your code throws the correct exception
# (or even catches them) in weird cases
calc = Calculator()
# Can catch exceptions in pytest context manager
with pytest.raises(CalculatorError):
calc.add('1', 1)
def test_add_with_two_strings():
""" This test passes because the correct error is raised, not because it can add two strings,
but because the Calculator code can handle the mistake gracefully """
calc = Calculator()
with pytest.raises(CalculatorError) as context:
calc.add("two", "three")
assert str(context.value) == '"two" is not a number'
def test_add_lines_check_log(self, mock_write):
Calculator.add('\n'.join(map(str, range(100))))
mock_write.assert_called_once_with(100 * 99 / 2)
mock_write.reset_mock()
Calculator.add('\n'.join(map(str, range(0, 101, 2))))
mock_write.assert_called_once_with(50 * 51)
mock_write.reset_mock()
def testAdd(self):
calculator = Calculator()
self.assertEqual(4, calculator.add(2, 2))
self.assertEqual(5, calculator.add(2, 3))
self.assertEqual(-1, calculator.add(2, -3))
self.assertEqual(0, calculator.add(2, -2))
self.assertEqual(2, calculator.add(2, 0))
self.assertEqual(-5, calculator.add(-2, -3))
def test_add_one_check_log(self, mock_write):
Calculator.add("1")
mock_write.assert_called_once_with(1)
mock_write.reset_mock()
Calculator.add("12.56")
mock_write.assert_called_once_with(12.56)
mock_write.reset_mock()
def test_add_unkwown_check_log(self, mock_write):
Calculator.add(','.join(map(str, range(100))))
mock_write.assert_called_once_with(100 * 99 / 2)
mock_write.reset_mock()
Calculator.add(','.join(map(str, range(100, 201))))
mock_write.assert_called_once_with(200 * 201 / 2 - 100 * 99 / 2)
mock_write.reset_mock()
def test_add_lines(self):
self.assertEqual(
Calculator.add('\n'.join(map(str, range(100)))),
100 * 99 / 2
)
self.assertEqual(
Calculator.add('\n'.join(map(str, range(0, 101, 2)))),
50 * 51
)
def test_add_custom_separator_check_log \
(self, mock_write):
Calculator.add("//#\n1#2#3")
mock_write.assert_called_once_with(6)
mock_write.reset_mock()
Calculator.add("//##\n1##2##3")
mock_write.assert_called_once_with(6)
mock_write.reset_mock()
def test_add_unkwown(self):
self.assertEqual(
Calculator.add(','.join(map(str, range(100)))),
100 * 99 / 2
)
self.assertEqual(
Calculator.add(','.join(map(str, range(100, 201)))),
200 * 201 / 2 - 100 * 99 / 2
)
class TestCalculator(unittest.TestCase):
def setUp(self):
self.c = Calculator()
def test_add3To4ToGet7(self):
actual = self.c.add(3, 4)
self.assertEquals(7, actual)
def test_addTwoIntegers(self):
actual = self.c.add(5, 8)
self.assertEquals(13, actual)
def test_invalidFirstArgThrowsException(self):
self.assertRaises(ValueError, self.c.add, "three", 6)
class TddInPythonExample(unittest.TestCase):
# ran before each test
def setUp(self):
self.calc = Calculator()
# ran after each test
def tearDown(self):
pass
def test_calculator_add_method_returns_correct_result(self):
self.assertEqual(self.calc.add(2,2), 4)
def test_calculator_add_method_returns_correct_result_example_two(self):
self.assertEqual(self.calc.add(3,2), 5)
class TddInPythonExample(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_calculator_add_method_returns_correct_result(self):
result = self.calc.add(2, 2)
self.assertEqual(4, result)
def test_calculator_returns_error_message_if_both_args_not_numbers(self):
self.assertRaises(ValueError, self.calc.add, 'two', 'three')
def test_calculator_subtract_method_returns_correct_result(self):
result = self.calc.subtract(4,2)
self.assertEqual(2, result)
def test_calculator_returns_error_message_if_both_args_not_numbers(self):
self.assertRaises(ValueError, self.calc.subtract, "four", "two")
def test_calculator_multiply_method_returns_correct_result(self):
result = self.calc.multiply(3,5)
self.assertEqual(15, result)
def test_calculator_returns_error_message_if_both_args_not_number(self):
self.assertRaises(ValueError, self.calc.multiply, "three","five")
def test_calculator_divide_method_returns_correct_result(self):
result = self.calc.divide(15,3)
self.assertEqual(5, result)
def test_calcualtor_returns_error_message_if_btoh_args_not_number(self):
self.assertRaises(ValueError, self.calc.divide, "fifteen","three")
class TryingOutUnitTest(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_adding_two_numbers_should_pass(self):
result = self.calc.add(2, 2)
self.assertEquals(4, result)
def test_adding_two_number_should_fail(self):
result = self.calc.add(2, 4)
self.assertNotEqual(4, result)
def test_adding_int_and_text_fails(self):
result = self.calc.add("hello", 2)
self.assertRaises(TypeError)
def test_add():
calc = Calculator()
(4).should.equal(calc.add(2, 2))
calc.add.when.called_with('two', 'three').should.throw(ValueError)
calc.add.when.called_with('two', 3).should.throw(ValueError)
calc.add.when.called_with(2, 'three').should.throw(ValueError)
class TestCalculator(unittest.TestCase):
@classmethod
def setUpClass(self):
# Create an instance of the calculator that can be used in all tests
self.calc = Calculator()
print('Set up class')
@classmethod
def tearDownClass(self):
print('Tear down class')
def test_add(self):
self.assertEqual(self.calc.add(2, 7), 9)
# Write test methods for subtract, multiply, and divide
def test_subtract(self):
self.assertEqual(self.calc.subtract(5, 3), 2)
def test_multiply(self):
self.assertEqual(self.calc.multiply(2, 7), 14)
def test_divide(self):
self.assertEqual(self.calc.divide(14, 7), 2)
class TestCalculator(unittest.TestCase):
def setUp(self):
self.c = Calculator()
def tearDown(self):
pass
def test_add(self):
# NOTE: Bad failed assertion message. Just for fun :)
self.assertEqual(self.c.add(1,2),3,"Alamak?")
def test_sub(self):
self.assertEqual(self.c.sub(1,2),-1,"Invalid subtraction")
def test_mul(self):
self.assertEqual(self.c.mul(1,2),2,"Invalid multiplication")
def test_div(self):
# Ref: http://stackoverflow.com/a/4842318/822340
self.assertEqual(self.c.div(1,2),0.5,"Invalid division")
def test_div_by_zero(self):
with self.assertRaisesRegex(Exception, "Haha Very Funny"):
self.c.div(1,0)
class TddCalculator(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_calculator_add_method_returns_correct_result(self):
result = self.calc.add(2, 2)
self.assertEqual(4, result)
def test_calculator_returns_error_message_if_both_args_not_numbers(self):
self.assertRaises(ValueError, self.calc.add, "two", "three")
def test_calculator_returns_error_message_second(self):
self.assertRaises(ValueError, self.calc.add, 2, "three")
def test_calculator_assert_not_equal(self):
result = self.calc.add(3, 4)
self.assertNotEqual(6, result)
def test_adds_numbers(self):
# Arrange
calculator = Calculator()
# Act
result = calculator.add(1, 2)
# Assert
self.assertEqual(3, result)
class TestCalculator(unittest.TestCase):
'''Test Calculator module.'''
def setUp(self):
self.calc = Calculator()
def test_sum(self):
'''Test sum operation.'''
answer = self.calc.add(2, 4)
self.assertEqual(answer, 6)
def test_invalid_string(self):
calc = Calculator()
calc.expr = "a,b"
try:
result = calc.add()
finally:
result = -1
self.assertEqual(result, -1)
class TestCalc(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_add(self):
result = self.calc.add(2, 2)
self.assertEqual(4, result)
def test_error_if_not_numbers(self):
self.assertRaises(ValueError, self.calc.add, 'two', 'three')
class TddInPythonExample(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_calculator_add_method_returns_correct_result(self):
result = self.calc.add(2,2)
self.assertEqual(4, result)
def test_calculator_add_method_returns_correct_result2(self):
result = self.calc.add(2,7)
self.assertEqual(9, result)
def test_3(self):
call = self.calc.add, 'two', 'three'
self.assertRaises(ValueError, *call)
def test_4(self):
self.assertRaises(ValueError, self.calc.add, 6, 'three')
def test_5(self):
self.assertRaises(ValueError, self.calc.add, 'three', 6)
class Mytest(unittest.TestCase):
def setUp(self):
self.foo = Calculator(3,2)
def test_add(self):
self.assertEqual(self.foo.add(), 5)
def test_sub(self):
self.assertEqual(self.foo.sub(),1)
def test_mul(self):
self.assertEqual(self.foo.mul(),6)
def test_div(self):
self.assertEqual(self.foo.div(), 1)
class TestCalc(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_calc_addition_for_correct_result(self):
result = self.calc.add(2,2)
self.assertEqual(4, result)
def test_error_message_if_both_not_numbers(self):
self.assertRaises(ValueError, self.calc.add, 'two', 'three')
def test_error_message_if_one_of_the_args_is_not_a_number(self):
self.assertRaises(ValueError, self.calc.add, 'two', 3)
self.assertRaises(ValueError, self.calc.add, 2, 'three')
class CalculatorTestCase(unittest.TestCase): def setUp(self): self.c = Calculator() def testAdd(self): res = self.c.add(1, 1.2) self.assertEquals(2.2, res) def testSub(self): res = self.c.sub(13.2, 10.4) self.assertEquals(2.8, res) def testMul(self): res = self.c.mul(12, 0.1) self.assertEquals(1.2, res) def testDiv(self): res = self.c.div(0.3, 0.1) self.assertEquals(3, res) def testZeroDiv(self): self.assertRaises(ValueError, self.c.div, 5, 0) def testMyPowerZero(self): res = self.c.my_pow(3, 0) self.assertEquals(1, res) def testMyPowerNegativeToFractional(self): self.assertRaises(ValueError, self.c.my_pow, -2, 3.45) def testMyPowerZeroToNegative(self): self.assertRaises(ValueError, self.c.my_pow, 0, -2) def testMyPowerFractionalDegree(self): res = self.c.my_pow(4, 1.5) self.assertEquals(8, res) def testMyPowerIntegerNegativeDegree(self): res = self.c.my_pow(2, -3) self.assertEquals(0.125, res) def testMyPowerIntegerPositiveDegree(self): res = self.c.my_pow(0.1, 2) self.assertEquals(0.01, res) def testMyPowerFloatFractionalDegree(self): res = self.c.my_pow(1.44, 0.5); self.assertEquals(1.2, res)
class TDDinCalculator(unittest.TestCase): def test_calculator_add(self): self.calc = Calculator() result = self.calc.add(2,3) self.assertEqual(5, result) def test_calculator_add_strings(self): self.calc = Calculator() self.assertRaises(ValueError, self.calc.add, 'two', 'three') def test_calculator_add_strings_one(self): self.calc = Calculator() self.assertRaises(ValueError, self.calc.add, 2, 't')
class TddInPythonExample(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_calculator_add_method_returns_correct_result(self): result = self.calc.add(2, 2) self.assertEqual(4, result) def test_calculator_returns_error_message_if_both_args_not_numbers(self): self.assertRaises(ValueError, self.calc.add, 'two', 'three') def test_calculator_returns_error_message_if_x_arg_not_number(self): self.assertRaises(ValueError, self.calc.add, 'two', 3) def test_calculator_returns_error_message_if_y_arg_not_number(self): self.assertRaises(ValueError, self.calc.add, 2, 'three')
class TddInPythonExample(unittest.TestCase):
"""Tdd In Python Example."""
def setUp(self):
self.cal = Calculator()
def test_caculator_add_method_returns_correrct_result(self):
result = self.cal.add(2, 2);
self.assertEqual(4, result)
def test_caculator_return_error_message_if_both_args_not_numbers(self):
self.assertRaises(ValueError, self.cal.add, "two", "three")
def test_caculator_return_error_message_if_x_not_numbers(self):
self.assertRaises(ValueError, self.cal.add, "two", 3)
def test_caculator_return_error_message_if_y_not_numbers(self):
self.assertRaises(ValueError, self.cal.add, 2, "three")
class CalculatorTest(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_add(self):
result = self.calc.add(4, 8)
self.assertEqual(12, result)
def test_subtract(self):
result = self.calc.subtract(8, 4)
self.assertEqual(4, result)
def test_multiply(self):
result = self.calc.multiply(8, 4)
self.assertEqual(32, result)
def test_divide(self):
result = self.calc.divide(8, 4)
self.assertEqual(2, result)
class CalculatorTest(TestCase):
def setUp(self):
self.calc = Calculator()
operations = lambda: ((6, 3, 9), (-8, 4, -4), (4, -3, 1), (-7, -8, -15), (2.7, 3.56, 6.26), (-4.44, 6.759, 2.319),
(5.53, -7.68, -2.15), (-24.9, -6.53, -31.43), (0, -3.43, -3.43), (0, 0, 0), (4.7, 0, 4.7))
@data_provider(operations)
def test_add(self, a, b, ans):
self.assertEqual(ans, round(self.calc.add(a, b), 3))
operations = lambda: ((6, 3, 3), (-8, 4, -12), (4, -3, 7), (-7, -8, 1), (2.7, 3.56, -0.86), (-4.44, 6.759, -11.199),
(5.53, -7.68, 13.21), (-24.9, -6.53, -18.37), (0, -3.43, 3.43), (0, 0, 0), (4.7, 0, 4.7))
@data_provider(operations)
def test_subtract(self, a, b, ans):
self.assertEqual(ans, round(self.calc.subtract(a, b), 3))
operations = lambda: ((6, 3, 18), (-8, 4, -32), (4, -3, -12), (-7, -8, 56), (2.7, 3.56, 9.612), (-4.44, 6.759, -30.01),
(5.53, -7.68, -42.47), (-24.9, -6.53, 162.597), (0, -3.43, -0), (0, 0, 0), (4.7, 0, 0))
@data_provider(operations)
def test_multiply(self, a, b, ans):
self.assertEqual(ans, round(self.calc.multiply(a, b), 3))
operations = lambda: ((6, 3, 2), (-8, 4, -2), (4, -3, -1.333), (-7, -8, 0.875), (2.7, 3.56, 0.758), (-4.44, 6.759, -0.657),
(5.53, -7.68, -0.72), (-24.9, -6.53, 3.813), (0, -3.43, -0))
@data_provider(operations)
def test_divide(self, a, b, ans):
self.assertEqual(ans, round(self.calc.divide(a, b), 3))
with self.assertRaises(ZeroDivisionError):
self.calc.divide(4.7, 0)
def test_evaluate(self):
self.assertEqual(-6, self.calc.evaluate("3+(4-7)*3"))
self.assertEqual(17, self.calc.evaluate("2.5*3.2+(4.7-3.2)*6"))
with self.assertRaises(ZeroDivisionError):
self.calc.evaluate("2/0")
class TddInPythonExample(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
print "Instantiated a Calculator into the calc variable"
def test_calculator_add_method_returns_correct_result(self):
#calc = Calculator()
result = self.calc.add(2,2)
self.assertEqual(4, result)
print "Tested calc.add(2,2)"
def test_calculator_returns_error_message_if_both_args_not_numbers(self):
self.assertRaises(ValueError, self.calc.add, 'two', 'three')
print "Tested calc.add('two','three')"
def test_calculator_returns_error_message_if_x_arg_not_number(self):
self.assertRaises(ValueError, self.calc.add, 'two', 3)
print "Tested calc.add('two',3)"
def test_calculator_returns_error_message_if_x_arg_not_number(self):
self.assertRaises(ValueError, self.calc.add, 2, 'three')
print "Tested calc.add(2,'three')"
def test_return_0_on_empty_string(self):
c = Calculator()
self.assertEqual(c.add(""), 0)
def test_single_digit_string(self):
calc = Calculator("1")
result = calc.add()
self.assertEqual(result, 1)
def test_spaces_string(self):
calc = Calculator(" ")
result = calc.add()
self.assertEqual(result, 0)
def test_two_digit_string(self):
calc = Calculator("1,2")
result = calc.add()
self.assertEqual(result, 3)
