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
