class CalcTest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) def test_add2(self): self.assertEqual(self.calc.add(99, 5), 104) def test_subtract(self): self.assertEqual(self.calc.subtract(6, 4), 2) def test_subtract2(self): self.assertEqual(self.calc.subtract(74, 5), 69) def test_multiply(self): self.assertEqual(self.calc.multiply(3, 4), 12) def test_multiply2(self): self.assertEqual(self.calc.multiply(17, 17), 289) def test_divide(self): self.assertEqual(self.calc.divide(10, 2), 5) def test_divide2(self): self.assertEqual(self.calc.divide(529, 23), 23)
class Calctest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) def test_add2(self): self.assertEqual(self.calc.add(26, 7), 33) def test_subtract(self): self.assertEqual(self.calc.subtract(6, 4), 2) def test_subtract2(self): self.assertEqual(self.calc.subtract(6, 3), 3) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) def test_multiply2(self): self.assertEqual(self.calc.multiply(12, 12), 144) def test_divide(self): self.assertEqual(self.calc.divide(10, 2), 5) def test_divide2(self): self.assertEqual(self.calc.divide(220, 2), 110)
class CaclTest(unittest.TestCase): calc = SimpleCalc() # create an object of our SimpleCalc() class def test_add( self ): # Naming convention - using test in the name of our function will let python interpretor know that this need to be tested # 2+2=4 outcome is True self.assertEqual(self.calc.add(2, 4), 6) # this test is checking if 2+4=6 that would be true, if true test will pass def test_substract(self): self.assertEqual(self.calc.substract(4, 2), 2) # This tests the values as 4-2=2 to be True if True the test passes def test_multiply(self): self.assertEqual(self.calc.multiply(3, 3), 9) # This tests the values as 3*3=9 to be True def test_divide(self): self.assertEqual(self.calc.divide(8, 4), 2) # This test the values as 8/4=2 if True # pytest looks for any file wtih name including test.*.py
class CalcTest(unittest.TestCase): calc = SimpleCalc() def test_add( self ): # Naming convention - using "test" before or after when naming our function will let python interpreter know that this needs to be tested self.assertEqual( self.calc.add(2, 4), 6) # This test is checking "2 + 4 = 6", if true it will pass def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) # This test is checking if "4 - 2 = 2", if true it will pass def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) # This test will check if 2 x 2 = 4 def test_divide(self): self.assertEqual(self.calc.divide(15, 3), 5) # This test will check "15 / 3 = 5" # PyTest looks for anyfile with the name "test.___.py"
class CalcTest(unittest.TestCase): # inittest.TestCase works with unittest framework as a parent class calc = SimpleCalc() # Creating an object of our class # IMPORTANT - we MUST use test word in our functions so py interpreter knows what we are testing # need the test_ otherwise tests wont run def test_add(self): # self.assertEqual(self.calc.add(2,4), 6) 2+4 should equal six, if so returns True self.assertEqual(self.calc.add(2, 4), 6) # What are we asking python to test for us # We are asking python to test/check if 2 + 4 = 6 if True pass teh test if False fail the test def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) # bool def test_multiply(self): self.assertEqual(self.calc.multiply(3, 4), 12) def test_divide(self): self.assertEqual(self.calc.divide(8, 2), 4)
class Calc_tests(unittest.TestCase): #Initiating a calculator object so we can test its behaviour calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6, "You failed to get 6, adding 2 + 4") def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) def test_divide(self): self.assertEqual(self.calc.divide(6, 3), 2) def test_calculator_initiated(self): self.assertIsInstance(self.calc, SimpleCalc, msg="Is it a calculator object?") #- There should be a calculator object # - It should add two numbers # - It should subtract two numbers # - It should multiply two # - It should divide two numbers # - Nice to have: It could keep the last result in memory.
class CalcTest(unittest.TestCase): # IMPORTANT - we must use TEST word in our functions, so python interpretor # knows what we are testing # Test the add function def test_add(self): # self.assertEqual(self.calc.add(num1, num2), total) # checks the numbers in the original function, and it should come to 6 self.assertEqual(self.calc.add(2, 4), 6) # True if pass # Test the subtract function def test_subtract(self): # Test if 4 - 2 = 2 self.assertEqual(self.calc.subtract(4, 2), 2) # True if pass def test_multiply(self): # Test if 4 * 2 = 8 self.assertEqual(self.calc.multiply(4, 2), 8) # True if pass def test_divide(self): self.assertEqual(self.calc.divide(6, 3), 2) # creating an object of our class calc = SimpleCalc()
class CalcTest(unittest.TestCase): # unittest.TestCase is a framework with unittest as Parent class # create instance of class to be tested calc = SimpleCalc() # use 'test' in function name so python interpreter understands that this is a test function def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) # Boolean: is add(2, 4) == 6 # Tests to see whether passing in (2, 4) in the add function of SimpleClass returns 6 # 2 + 4 = 6 def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) # Boolean: is subtract(4, 2) == 2 # Tests to see whether passing in (4, 2) in the add function of SimpleClass returns 2 # 4 - 2 = 2 def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) # Boolean: is multiply(2, 2) == 4 # Tests to see whether passing in (2, 2) in the add function of SimpleClass returns 4 # 2 * 2 = 4 def test_divide(self): self.assertEqual(self.calc.divide(6, 3), 2) # Boolean: is divide(6, 3) == 2
class CalcTest(unittest.TestCase): calc = SimpleCalc() def test_add(self): # Naming convention - using 'test' in name of function self.assertEqual(self.calc.add(2, 4), 6) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): self.assertEqual(self.calc.multiply(5, 3), 15) def test_divide(self): self.assertEqual(self.calc.divide(18, 6), 3)
class Calctests(unittest.TestCase): cal = SimpleCalc() # create an object def test_add(self): self.assertEqual(self.cal.add(2, 4), 6) # assertEqual means does LHS [add(2,4)] equal to RHS [6] def test_substract(self): self.assertEqual(self.cal.substract(4, 2), 2) def test_multiply(self): self.assertEqual(self.cal.multiply(2, 2), 4) def test_divide(self): self.assertEqual(self.cal.divide(6, 2), 3)
class Calctests(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 4), 8) def test_divide(self): self.assertEqual(self.calc.divide(4, 2), 2)
class TestCalc(unittest.TestCase): calc = SimpleCalc() # start each method with keyword test_ def test_add(self): # returns True if 2 + 4 returns 6, otherwise False self.assertEqual(self.calc.add(2, 4), 6) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 3), 6) def test_divide(self): self.assertEqual(self.calc.divide(10, 2), 5)
class Calctests(unittest.TestCase): calc = SimpleCalc() def test_add(self): # Syntax of assertEqual(<test>, <result>) self.assertEqual(self.calc.add(2, 4), 6) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 3), 6) def test_divide(self): self.assertEqual(self.calc.divide(8, 4), 2)
class Calctests(unittest.TestCase): calc = SimpleCalc() def test_add(self): # syntax assertEqual(#test, #result) self.assertEqual(self.calc.add(2, 4), 6) def test_subtract(self): self.assertEqual(self.calc.subtract(2, 4), -2) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 4), 8) def test_divide(self): self.assertEqual(self.calc.divide(6, 3), 2)
class CalcTest(unittest.TestCase): calc = SimpleCalc() def test_add(self): # You must have 'test' in the name of these functions - if not, the python interpreter won't know what to test # checks that 2 + 4 = 6 using the add method that was implemented self.assertEqual(self.calc.add(2, 4), 6) # returns True if it passes def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 4), 8) def test_divide(self): self.assertEqual(self.calc.divide(21, 3), 7)
class CalcTest(unittest.TestCase): calc = SimpleCalc() # creating an object of our SimpleCalc() class def test_add(self): # naming convention - using test in the name of our # function will let python interpreter know that this needs to be tested self.assertEqual(self.calc.add(2, 4), 6) # this test is checking if 2 + 2 = 6 that would be true, if true test will pass def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) # This tests the values as 4 - 2 = 2 to be True, if True the test passes def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) # This tests the values as 2 * 2 = 4 to be True def test_divide(self): self.assertEqual(self.calc.divide(15, 3), 5)
class TestSimpleCalc(unittest.TestCase): calc = SimpleCalc() # create an object def test_add(self): result = self.calc.add(2, 4) self.assertEqual(result, 6) def test_subtract(self): result = self.calc.subtract(4, 2) self.assertEqual(result, 2) def test_multiply(self): result = self.calc.multiply(2, 2) self.assertEqual(result, 4) def test_divide(self): result = self.calc.divide(6, 2) self.assertEqual(result, 3)
class Calctest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) self.assertEqual(self.calc.add(4, 4), 8) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) self.assertEqual(self.calc.subtract(5, 4), 1) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 3), 6) self.assertEqual(self.calc.multiply(2, 2), 4) def test_divide(self): self.assertEqual(self.calc.divide(8, 4), 2) self.assertEqual(self.calc.divide(9, 3), 3)
class Calctest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) self.assertEqual(self.calc.add(4, 4), 8) def test_subtract(self): self.assertEqual(self.calc.subtract(2, 4), -2) self.assertEqual(self.calc.subtract(10, 5), 5) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 3, ), 6) self.assertEqual(self.calc.multiply(10, 8, ), 80) def test_divide(self): self.assertEqual(self.calc.divide(8, 4), 2) self.assertEqual(self.calc.divide(16, 8), 2)
class CalcTest(unittest.TestCase): calc = SimpleCalc() # Create an instance for use in testing def test_add(self): # Must use "test" in the function name self.assertEqual(self.calc.add(2, 4), 6) # see if the result of this method is 6 def test_sub(self): self.assertEqual(self.calc.subtract(10, 5), 4) # see if the result of this method is 5 def test_mult(self): self.assertEqual(self.calc.multiplication(6, 2), 12) # see if the result of this method is 12 def test_div(self): self.assertEqual(self.calc.division(9, 3), 3) # see if the result of this method is 3
class Calctest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) self.assertEqual(self.calc.add(12, 4), 16) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) self.assertEqual(self.calc.subtract(14, 2), 12) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 3), 6) self.assertEqual(self.calc.multiply(32, 3), 96) def test_divide(self): self.assertEqual(self.calc.divide(8, 4), 2) self.assertEqual(self.calc.divide(28, 4), 7)
class Calctest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) self.assertEqual(self.calc.add(9, 13), 22) self.assertNotEqual(self.calc.add(45, 5), 56) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) self.assertEqual(self.calc.subtract(18, 9), 9) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 3), 6) self.assertEqual(self.calc.multiply(5, 30), 150) def test_divide(self): self.assertEqual(self.calc.divide(8, 4), 2) self.assertEqual(self.calc.divide(80, 8), 10)
class CalcTest(unittest.TestCase): calc = SimpleCalc() # Naming convention: 'test_' before name of the function def test_add(self): # Test if teh value of 2+4 is equal to 6 when using calc.add() self.assertEqual(self.calc.add(2, 4), 6) def test_subtract(self): # Test if the value of 4-2 is equal to 2 when using calc.subtract() self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): # Test if the value of 2*2 is equal to 4 when using calc.multiply() self.assertEqual(self.calc.multiply(2, 2), 4) def test_divide(self): # Test if the value of 512/32 is equal to 16 when using calc.divide() self.assertEqual(self.calc.divide(512, 32), 16)
class CalcTest(unittest.TestCase): calc = SimpleCalc() # creating an object of our SimpleCalc class def test_add( self ): # Naming convention - using `test` in the name of our function will let # python interpreter know what needs to be tested self.assertEqual(self.calc.add(2, 4), 6) # this test is checking if 2 + 4 = 6 would be true if true test will pass def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) # this test is checking if 4 - 2 = 2 would be true if true test will pass def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) # this test is checking if 2 * 2 = 4 would be true if true test will pass def test_divide(self): self.assertEqual(self.calc.divide(15, 3), 5)
class CalcTest(unittest.TestCase): calc = SimpleCalc() def test_add( self ): # naming convention - using `test` in the name of the function will let python interpreter know that this needs to be tested self.assertEqual(self.calc.add(2, 4), 6) # this test is checking if 2 + 4 = 6, if true test will pass def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) # this tests the values as 4 - 2 = 2, if true test will pass def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) # this tests the values 2 * 2 = 4, if true the test passes def test_divide(self): self.assertEqual(self.calc.divide(15, 3), 5)
class CalcTest(unittest.TestCase): # Create an object calc = SimpleCalc() ### IMPORTANT - Must use the 'test' word in our methods def test_add(self): # We are asking python to test if 2 + 4 = 6 self.assertEqual(self.calc.add(2, 4), 6) # Test if 4 - 2 =2 def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) # Test if 2 x 2 = 4 def test_multiply(self): self.assertEqual(self.calc.multiply(2, 2), 4) # Test if 6 / 3 = 2 def test_divide(self): self.assertEqual(self.calc.divide(6, 3), 2)
class CalcTest(unittest.TestCase): calc = SimpleCalc() # Create SimpleCalc object # Using "test" in the same of our function will let # the python interpreter know that this needs to be tested def test_add(self): # Tests if 2 + 4 = 6. If true, the test will pass. self.assertEqual(self.calc.add(2, 4), 6) def test_subtract(self): # Tests if 4 - 2 = 2. If true, the test will pass. self.assertEqual(self.calc.subtract(4, 2), 2) def test_multiply(self): # Tests if 2 x 2 = 4. If true, the test will pass. self.assertEqual(self.calc.multiply(2, 2), 4) def test_divide(self): # Tests if 15 / 3 = 5. If true, the test will pass. self.assertEqual(self.calc.divide(15, 3), 5)
class Calctest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2,4), 6) self.assertEqual(self.calc.add(400,600), 1000) def test_subract(self): self.assertEqual(self.calc.subtract(6,4), 2) self.assertEqual(self.calc.subtract(55,30), 25) def test_multiply(self): self.assertEqual(self.calc.multiply(2,2), 4) self.assertEqual(self.calc.multiply(4, 5), 20) def test_divide(self): # cal.divide(10,2) == 5 self.assertEqual(self.calc.divide(10,2), 5) self.assertEqual(self.calc.divide(10, 10), 1)
class Calctest(unittest.TestCase): calc = SimpleCalc() def test_add(self): self.assertEqual(self.calc.add(2, 4), 6) self.assertEqual(self.calc.add(5, 4), 9) def test_subtract(self): self.assertEqual(self.calc.subtract(4, 2), 2) self.assertEqual(self.calc.subtract(8, 4), 4) def test_multiply(self): self.assertEqual(self.calc.multiply(5, 6), 30) self.assertEqual(self.calc.multiply(2, 3), 6) def test_divide(self): self.assertEqual(self.calc.divide(16, 4), 4) self.assertEqual(self.calc.divide(8, 4), 2) def test_add2(self): self.assertEqual(self.calc.add(3, 5), 8)
class CalcTest(unittest.TestCase): # Create an object of our class calc = SimpleCalc() def test_add(self): # We are asking python to test/check if 2 + 4 =6. If True, passes the test, otherwise fails. self.assertEqual(self.calc.add(2, 4), 6) # Bool # We can repeat this for subtract def test_subtract(self): # Tests if 6-4=2. If True, pass. If False, fail self.assertEqual(self.calc.subtract(6, 4), 2) # Bool # And for multiply def test_multiply(self): # Tests if 2 * 4 is 8. If True, pass. If False, fail self.assertEqual(self.calc.multiply(2, 4), 8) # Bool def test_divide(self): # Tests if 12/4=3. If True, passes. False= fails self.assertEqual(self.calc.divide(12, 4), 3) # Bool