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 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 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)