고급 사용자를 위한 Python Unittest - ohipark/btstack GitHub Wiki

# math_functions.py
def addition(a, b):
    return a + b
 
def subtraction(a, b):
    return a - b
 
def multiplication(a, b):
    return a * b
 
def division(a, b):
    return a / b

# test_math_functions.py
 
import unittest
from math_functions import *
 
# Define class to test the program
class TestMathFunctions(unittest.TestCase):
    # Function to test addition function
    def test_addition(self):
        result = addition(2, 2)
        self.assertEqual(result, 4)
         
    # Function to test addition function
    def test_subtraction(self):
        result = subtraction(4, 2)
        self.assertEqual(result, 2)
         
   # Function to test addition function
    def test_multiplication(self):
        result = multiplication(2, 3)
        self.assertEqual(result, 6)
         
    # Function to test addition function
    def test_division(self):
        result = division(4, 2)
        self.assertEqual(result, 2)
 
if __name__ == '__main__':
    unittest.main()

$ Python -m unittest

# Program with error in one function
def addition(a, b):
    return "error_causing_format"
 
def subtraction(a, b):
    return a - b
 
def multiplication(a, b):
    return a * b
 
def division(a, b):
    return a / b

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    
    # negative test function to test if values1 is less or equal than value2 
    def test_negativeForLessEqual(self): 
        first = 6
        second = 5
          
        # error message in case if test case got failed 
        message = "first value is not less than or equal to second value."
          
        # assert function() to check if values1 is less or equal than value2 
        self.assertLessEqual(first, second, message) 
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    
    # positive test function to test if value1 is less or equal than value2 
    def test_positiveForLessEqual(self): 
        first = 4
        second = 4
          
        # error message in case if  test case got failed 
        message = "first value is not less than or equal to second value."
          
        # assert function() to check if values1 is less or equal than value2 
        self.assertLessEqual(first, second, message) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function to test whether key is present in container 
    def test_negative(self): 
        key = "geeks"
        container = "geeksforgeeks"
        # error message in case if test case got failed 
        message = "key is present in container."
        # assertNotIn() to check if key is in container 
        self.assertNotIn(key, container, message) 
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
  
class TestStringMethods(unittest.TestCase): 
    # test function to test whether key is present in container 
    def test_positive(self): 
        key = "gfgs"
        container = "geeksforgeeks"
        # error message in case if test case got failed 
        message = "key is present in container."
        # assertNotIn() to check if key is in container 
        self.assertNotIn(key, container, message) 
  
  
if __name__ == '__main__': 
    unittest.main() 

 test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function to test whether key is present in container 
    def test_negative(self): 
        key = "geeks"
        container = "geeksforgeeks"
        # error message in case if test case got failed 
        message = "key is present in container."
        # assertNotIn() to check if key is in container 
        self.assertNotIn(key, container, message) 
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
  
class TestStringMethods(unittest.TestCase): 
    # test function to test whether key is present in container 
    def test_positive(self): 
        key = "gfgs"
        container = "geeksforgeeks"
        # error message in case if test case got failed 
        message = "key is present in container."
        # assertNotIn() to check if key is in container 
        self.assertNotIn(key, container, message) 
  
  
if __name__ == '__main__': 
    unittest.main() 

# unit test case 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function to test equality of two value 
    def test_negative(self): 
        firstValue = "geeks"
        secondValue = "geeksg"
        # error message in case if test case got failed 
        message = "First value and second value are not unequal !"
        # assertNotEqual() to check unequality of first & second value 
        self.assertNotEqual(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function to test equality of two value 
    def test_positive(self): 
        firstValue = "geeks"
        secondValue = "geeks"
        # error message in case if test case got failed 
        message = "First value and second value are not unequal !"
        # assertNotEqual() to check equality of first & second value 
        self.assertNotEqual(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case
import unittest
 
class TestStringMethods(unittest.TestCase):
    # test function 
    def test_negative(self):
        testValue = False
        # error message in case if test case got failed
        message = "Test value is not true."
        # assertTrue() to check true of test value
        self.assertTrue( testValue, message)
 
if __name__ == '__main__':
    unittest.main()

# unit test case
import unittest
 
class TestStringMethods(unittest.TestCase):
    # test function 
    def test_positive(self):
        testValue = True
        # error message in case if test case got failed
        message = "Test value is not true."
        # assertTrue() to check true of test value
        self.assertTrue( testValue, message)
 
if __name__ == '__main__':
    unittest.main()

# unit test case 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function  
    def test_negative(self): 
        testValue = True
        # error message in case if test case got failed 
        message = "Test value is not false."
        # assetFalse() to check test value as false 
        self.assertFalse( testValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function  
    def test_positive(self): 
        testValue = False
        # error message in case if test case got failed 
        message = "Test value is not false."
        # assertFalse() to check test value as false 
        self.assertFalse( testValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class DummyClass: 
  x = 5
  
class TestMethods(unittest.TestCase): 
    # test function  
    def test_negative(self): 
        firstValue = DummyClass() 
        secondValue = firstValue 
        # error message in case if test case got failed 
        message = "First value & second value evaluates to same object !"
        # assertIs() to check that if first & second don't evaluated to same object 
        self.assertIsNot(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class DummyClass: 
  x = 5
  
class TestMethods(unittest.TestCase): 
    # test function to test object equality of two value 
    def test_positive(self): 
        firstValue = DummyClass() 
        secondValue = DummyClass() 
        # error message in case if test case got failed 
        message = "First value and second value evaluated to same object !"
        # assertIs() to check that if first & second don't evaluates to same object 
        self.assertIsNot(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main() 

# unit test case 
import unittest 
  
class DummyClass: 
  x = 5
  
class TestMethods(unittest.TestCase): 
    # test function to test object equality of two value 
    def test_negative(self): 
        firstValue = DummyClass() 
        secondValue = DummyClass() 
        # error message in case if test case got failed 
        message = "First value & second value are not evaluated to same object !"
        # assertIs() to check that if first & second evaluated to same object 
        self.assertIs(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class DummyClass: 
  x = 5
  
class TestMethods(unittest.TestCase): 
    # test function to test object equality of two value 
    def test_positive(self): 
        firstValue = DummyClass() 
        secondValue = firstValue 
        # error message in case if test case got failed 
        message = "First value and second value are not evaluated to same object !"
        # assertIs() to check that if first & second evaluated to same object 
        self.assertIs(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class TestMethods(unittest.TestCase): 
    # test function  
    def test_negative(self): 
        firstValue = "geeks"
        # error message in case if test case got failed 
        message = "Test value is not none."
        # assertIsNone() to check that if input value is none 
        self.assertIsNone(firstValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
  
class TestMethods(unittest.TestCase): 
    # test function  
    def test_positive(self): 
        firstValue = None
        # error message in case if test case got failed 
        message = "Test value is not none."
        # assertIsNone() to check that if input value is none 
        self.assertIsNone(firstValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class TestMethods(unittest.TestCase): 
    # test function  
    def test_negative(self): 
        firstValue = None
        # error message in case if test case got failed 
        message = "Test value is none."
        # assertIsNotNone() to check that if input value is not none 
        self.assertIsNotNone(firstValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class TestMethods(unittest.TestCase): 
    # test function  
    def test_positive(self): 
        firstValue = "geeks"
        # error message in case if test case got failed 
        message = "Test value is  none."
        # assertIsNotNone() to check that if input value is not none 
        self.assertIsNotNone(firstValue, message) 
  
if __name__ == '__main__': 
    unittest.main()

# unit test case 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function to test equality of two value 
    def test_negative(self): 
        firstValue = "geeks"
        secondValue = "gfg"
        # error message in case if test case got failed 
        message = "First value and second value are not equal !"
        # assertEqual() to check equality of first & second value 
        self.assertEqual(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main() 

# unit test case 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function to test equality of two value 
    def test_positive(self): 
        firstValue = "geeks"
        secondValue = "geeks"
        # error message in case if test case got failed 
        message = "First value and second value are not equal !"
        # assertEqual() to check equality of first & second value 
        self.assertEqual(firstValue, secondValue, message) 
  
if __name__ == '__main__': 
    unittest.main() 

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    # test function to test whether key is present in container 
    def test_negative(self): 
        key = "gfg"
        container = "geeksforgeeks"
        # error message in case if test case got failed 
        message = "key is not in container."
        # assertIn() to check if key is in container 
        self.assertIn(key, container, message) 
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
  
class TestStringMethods(unittest.TestCase): 
    # test function to test whether key is present in container 
    def test_positive(self): 
        key = "geeks"
        container = "geeksforgeeks"
        # error message in case if test case got failed 
        message = "key is not in container."
        # assertIn() to check if key is in container 
        self.assertIn(key, container, message) 
  
  
if __name__ == '__main__': 
    unittest.main() 

# test suite 
import unittest 
  
# test class 
class Myclass: 
    x = 5
  
class TestClass(unittest.TestCase): 
    # test function to test whether obj is instance of class 
    def test_negative(self): 
        objectName = Myclass() 
        # error message in case if test case got failed 
        message = "given object is  instance of Myclass."
        # assertIsInstance() to check if obj is instance of class 
        self.assertNotIsInstance(objectName, Myclass, message) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
# test class 
class Myclass: 
    x = 5
  
class Myclass2: 
    x = 5
      
class TestClass(unittest.TestCase): 
    # test function to test whether obj is instance of class 
    def test_negative(self): 
        objectName = Myclass() 
        # error message in case if test case got failed 
        message = "given object is instance of Myclass."
        # assert function() to check if obj is instance of class 
        self.assertNotIsInstance(objectName, Myclass2, message) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
# test class 
  
  
class Myclass: 
    x = 5
  
  
class Myclass2: 
    x = 6
  
  
class TestClass(unittest.TestCase): 
    # test function to test whether obj is instance of class 
    def test_negative(self): 
        objectName = Myclass() 
        # error message in case if test case got failed 
        message = "given object is not instance of Myclass."
        # assertIsInstance() to check if obj is instance of class 
        self.assertIsInstance(objectName, Myclass2, message) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
# test class 
class Myclass: 
    x = 5
  
  
class TestClass(unittest.TestCase): 
    # test function to test whether obj is instance of class 
    def test_positive(self): 
        objectName = Myclass() 
        # error message in case if test case got failed 
        message = "given object is not instance of Myclass."
        # assertIsInstance() to check if obj is instance of class 
        self.assertIsInstance(objectName, Myclass, message) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
  
class TestStringMethods(unittest.TestCase): 
    # negative test function to test if values are almost not-equal with place 
    def test_negativeWithPlaces(self): 
        first = 4.4555
        second = 4.4566
        decimalPlace = 2
        # error message in case if test case got failed 
        message = "first and second are almost equal."
        # assert function() to check if values are almost not-equal 
        self.assertNotAlmostEqual(first, second, decimalPlace, message) 
  
    # positive test function to test if values are almost not-equal with place 
    def test_positiveWithPlaces(self): 
        first = 4.4555
        second = 4.4566
        decimalPlace = 3
        # error message in case if test case got failed 
        message = "first and second are almost equal."
        # assert function() to check if values are almost not-equal 
        self.assertNotAlmostEqual(first, second, decimalPlace, message) 
  
    # negative test function to test if values are almost not-equal with delta 
    def test_negativeWithDelta(self): 
        first = 4.4555
        second = 4.4566
        delta = 0.002
        # error message in case if test case got failed 
        message = "first and second are almost equal."
        # assert function() to check if values are almost equal 
        self.assertNotAlmostEqual(first, second, None, message, delta) 
  
    # positive test function to test if values are almost not-equal with delta 
    def test_positiveWithDelta(self): 
        first = 4.4555
        second = 4.4566
        delta = 0.0001
        # error message in case if test case got failed 
        message = "first and second are almost equal."
        # assert function() to check if values are almost not-equal 
        self.assertNotAlmostEqual(first, second, None, message, delta) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    
    # negative test function to test if values1  
    # is greater than value2 
    def test_negativeForGreater(self): 
        first = 4
        second = 5
          
        # error message in case if test case got failed 
        message = "first value is not greater that second value."
          
        # assert function() to check if values1 is  
        # greater than value2 
        self.assertGreater(first, second, message) 
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    
    # positive test function to test if values 
    # are almost equal with place 
    def test_positiveForGreater(self): 
        first = 4
        second = 3
          
        # error message in case if test case got failed 
        message = "first value is not greater that second value."
          
        # assert function() to check if values1 is 
        # greater than value2 
        self.assertGreater(first, second, message) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
    
    # negative test function to test if values1 is greater or equal than value2 
    def test_negativeForGreaterEqual(self): 
        first = 4
        second = 5
          
        # error message in case if test case got failed 
        message = "first value is not greater or equal than second value."
          
        # assert function() to check if values1 is greater or equal than value2 
        self.assertGreaterEqual(first, second, message) 
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
  
    # positive test function to test if values1 is greater than or equal to value2 
    def test_positiveForGreaterEqual(self): 
        first = 4
        second = 4
          
        # error message in case if test case got failed 
        message = "first value is not greater or equal than second value."
          
        # assert function() to check if values1 is greater or equal than value2 
        self.assertGreaterEqual(first, second, message) 
  
  
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
      
    # negative test function to test if 
    # values1 is less than value2 
    def test_negativeForLess(self): 
        first = 6
        second = 5
          
        # error message in case if test case got failed 
        message = "first value is not less that second value."
          
        # assert function() to check if values1 is 
        # less than value2 
        self.assertLess(first, second, message) 
  
# main for function call 
if __name__ == '__main__': 
    unittest.main()

# test suite 
import unittest 
  
class TestStringMethods(unittest.TestCase): 
      
    # positive test function to test if  
    # values are almost equal with place 
    def test_positiveForLess(self): 
        first = 2
        second = 3
          
        # error message in case if test case got failed 
        message = "first value is not less that second value."
          
        # assert function() to check if values1 is 
        # less than value2 
        self.assertLess(first, second, message) 
  
# main for function call 
if __name__ == '__main__': 
    unittest.main()

# test suite
import unittest


class TestStringMethods(unittest.TestCase):
    # negative test function to test if values are almost equal with place
    def test_negativeWithPlaces(self):
        first = 4.4555
        second = 4.4566
        decimalPlace = 3
        # error message in case if test case got failed
        message = "first and second are not almost equal."
        # assert function() to check if values are almost equal
        self.assertAlmostEqual(first, second, decimalPlace, message)

    # positive test function to test if values are almost equal with place
    def test_positiveWithPlaces(self):
        first = 4.4555
        second = 4.4566
        decimalPlace = 2
        # error message in case if test case got failed
        message = "first and second are not almost equal."
        # assert function() to check if values are almost equal
        self.assertAlmostEqual(first, second, decimalPlace, message)

    # negative test function to test if values are almost equal with delta
    def test_negativeWithDelta(self):
        first = 4.4555
        second = 4.4566
        delta = 0.0001
        # error message in case if test case got failed
        message = "first and second are not almost equal."
        # assert function() to check if values are almost equal
        self.assertAlmostEqual(first, second, None, message, delta)

    # positive test function to test if values are almost equal with delta
    def test_positiveWithDelta(self):
        first = 4.4555
        second = 4.4566
        delta = 0.002
        # error message in case if test case got failed
        message = "first and second are not almost equal."
        # assert function() to check if values are almost equal
        self.assertAlmostEqual(first, second, None, message, delta)


if __name__ == '__main__':
    unittest.main()

import unittest 
  
# A simple function to illustrate 
def parse_int(s): 
    return int(s) 
  
class TestConversion(unittest.TestCase): 
    def test_bad_int(self): 
        self.assertRaises(ValueError, parse_int, 'N/A')

import errno 
  
class TestIO(unittest.TestCase): 
    def test_file_not_found(self): 
        try: 
            f = open('/file/not/found') 
        except IOError as e: 
            self.assertEqual(e.errno, errno.ENOENT) 
        else: 
            self.fail('IOError not raised') 

class TestConversion(unittest.TestCase): 
    def test_bad_int(self): 
        try: 
            r = parse_int('N/A') 
        except ValueError as e: 
            self.assertEqual(type(e), ValueError) 

class TestConversion(unittest.TestCase): 
    def test_bad_int(self): 
        try: 
            r = parse_int('N/A') 
        except ValueError as e: 
            self.assertEqual(type(e), ValueError) 
        else: 
            self.fail('ValueError not raised') 

class TestConversion(unittest.TestCase): 
    def test_bad_int(self): 
        self.assertRaisesRegex( 
                ValueError, 'invalid literal .*',  
                parse_int, 'N/A') 

class TestConversion(unittest.TestCase): 
    def test_bad_int(self): 
        with self.assertRaisesRegex(ValueError, 'invalid literal .*'): 
            r = parse_int('N/A') 

# import library
import unittest

# create a class
class TestXXXXX(unittest.TestCase):

    # define a function
    def test_xxxxxxx(self):
    
        data = [100, 200, 300]
        result = sum(data)
        self.assertEqual(result, 6000)

# driver code
if __name__ == '__main__':

    unittest.main()

# math_functions.py
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

# test_math_functions.py
import math_functions

def test_add():
    assert math_functions.add(2, 3) == 5
    assert math_functions.add(-1, 1) == 0
    assert math_functions.add(0, 0) == 0

def test_subtract():
    assert math_functions.subtract(5, 3) == 2
    assert math_functions.subtract(0, 0) == 0
    assert math_functions.subtract(-1, -1) == 0

# main.py

def test_addition():
    assert 1 + 1 == 2

def test_subtraction():
    assert 3 - 1 == 2

nosetests main.py

# main.py

def add(a, b):
    """
    Function to add two numbers.

    >>> add(2, 3)
    5
    >>> add(-1, 1)
    0
    """
    return a + b

def subtract(a, b):
    """
    Function to subtract two numbers.

    >>> subtract(5, 2)
    3
    >>> subtract(10, 5)
    4
    """
    return a - b

python -m doctest main.py

import unittest

class TestSumDifferentPatterns(unittest.TestCase):
    def test_list_tuple_values(self):

        # Summation of numbers present
        # in a tuple value
        data = (10*2, 200*2)
        result = sum(data)
        self.assertEqual(result, 600)

    def test_bad_data_type(self):
        data = "alpha value passed instead of numeric"
        
        with self.assertRaises(TypeError):
            result = sum(data)


if __name__ == '__main__':
    unittest.main()

python -m unittest discover

'''area module'''
 
def circle(radius):
    return 3.14 * radius ** 2
 
def square(side):
    return side ** 2
 
def rectangle(length, breadth):
    return length * breadth
 
def parallelogram(base, height):
    return base * height
 
def triangle(base, height):
    return 1/2 * (base * height)

import area
 
'''test_area file'''
 
class Test_Area:
 
    def test_circle(self):
        assert area.circle(14) == 615.44
 
    def test_square(self):
        assert area.square(4) == 16
 
    def test_rectangle(self):
        assert area.rectangle(6, 9) == 54
 
    def test_parallelogram(self):
        assert area.parallelogram(7, 5) == 35
 
    def test_triangle(self):
        assert area.triangle(12, 10) == 60

'''area module'''
 
def circle(radius):
    return 3.14 * radius
 
def square(side):
    return side ** 2
 
def rectangle(length, breadth):
    return length * breadth
 
def parallelogram(base, height):
    return base * height
 
def triangle(base, height):
    return 1/2 * (base * height)

# importing mock from unittest.mock module 
from unittest.mock import Mock 
  
# defining instance of our mock 
our_mock = Mock() 
  
# defining mock object’s __str__ method 
our_mock.__str__ = Mock(return_value='GeeksforGeeks Mocking Example') 
  
# executing str function for output 
print(str(our_mock))