EE308 LAB11

1. Aim

 This experiment is used to record the test process, summarize the test conditions of each round, and analyze the test data. Here, I use Python for convenience, so unittest task is my choice.

2.Task flow

1. unittest assert test

import unittest, random
 
 
# Test Class
class MyClass(object):
    @classmethod
    def sum(self, a, b):
        return a + b
    @classmethod
    def div(self, a, b):
        return a / b
    @classmethod
    def retrun_None(self):
        return None
 
 
# Unit Test Class
class MyTest(unittest.TestCase):
    # assertEqual()
    def test_assertEqual(self):
        # test if a+b equals sum or not
        try:
            a, b = 1, 2
            sum = 3
            self.assertEqual(a + b, sum, 'assert failed!，%s + %s != %s' % (a, b, sum))
        except AssertionError as e:
                print(e)
 
        # assertNotEqual()
    def test_assertNotEqual(self):
        # fix missing three lines of codes below ‘try’, test if b-a equals res or not
        try:
            a,b = 1, 2
            res = 1
            # Using assertNotEqual() to prove 2-1=1
            self.assertNotEqual(b-a,res,'assert true!，%s - %s == %s' %(b, a, res))
        except AssertionError as e:
            print(e)
 
    # assertTrue()
    def test_assertTrue(self):
 
        try:
            self.assertTrue(1 == 1, "False expression")
        except AssertionError as e:
            print(e)
 
    # assertFalse()
    def test_assertFalse(self):
        # fix missing codes below ‘try’, only a line of codes needed
        try:
            # Using assertFalse() to prove 1==1 reversely
            self.assertFalse(1 != 1, "True expression")
        except AssertionError as e:
            print(e)
 
        # assertIs()
    def test_assertIs(self):
        # test a and b are totally same
        try:
            a = 12
            b = a
            self.assertIs(a, b, "%s and %s are not same" % (a, b))
        except AssertionError as e:
            print(e)
 
        # assertIsInstance()
    def test_assertIsInstance(self):
        # fix missing codes below ‘y=object’ to test type(x) != y, only a line of codes needed
        try:
            x = MyClass
            y = object
            # Using assertIs() to prove obj is not same
            self.assertIs(x, y, "type(%s) and %s are not same" % (x, y))
        except AssertionError as e:
            print(e)
 
    if __name__ == '__main__':
        # run unittest
        unittest.main()

 2.unittest test groups

class Calc(object):
 
    def add(self, *d):
        #
        result = 0
        for i in d:
            result += i
        return result
 
    def mul(self, *d):
        #
        result = 1
        for i in d:
            result = result * i
        return result
 
 
    def sub(self, a, *d):
    #
        result = a
        for i in d:
            result = result - i
        return result
 
 
    def div(self, a, *d):
    #
        result = a
        for i in d:
            result = result / i
        return result
 
 
 
import unittest
import random
from Calc import Calc
 
 
class TestCalcFunctions(unittest.TestCase):
 
    def setUp(self):
        self.c = Calc()
        print("setup completed!")
 
    def test_sum(self):
        self.assertTrue(self.c.add(1, 2, 3, 4) == 10)
 
 
    def test_sub(self):
        # fix a line of codes to test c.sub(self, a, *b) method
        # Using assertFalse() to prove the -8 !=10
        self.assertFalse(self.c.sub(1, 2, 3, 4) == 10)
 
    def test_mul(self):
        # fix a line of codes to test c.mul(self, *b) method
        # Using assertTrue() to prove the 24 ==24
        self.assertTrue(self.c.mul(2, 3, 4) == 24)
 
    def test_div(self):
        # fix a line of codes to test c.div(self, a, *b) method
        # Using assertFalse() to prove the 1/24 !=10
        self.assertFalse(self.c.div(1, 2, 3, 4) == 10)
 
    def test(self):
        print("test completed!")
 
    def tearDown(self):
        print("tearDown completed")
 
 
if __name__ == '__main__':
    unittest.main()
 
 
 
 
import random
import unittest
from TestCalc import TestCalcFunctions
 
 
class TestSequenceFunctions(unittest.TestCase):
    def setUp(self):
        self.seq = list(range(10))
 
    def tearDown(self):
        pass
 
    def test_choice(self):
        # chose an element from seq randomly
        element = random.choice(self.seq)
        # check element is truly in the sequence
        self.assertTrue(element in self.seq)
 
    def test_sample(self):
        # if codes raise exception
        with self.assertRaises(ValueError):
            random.sample(self.seq, 20)
 
        for element in random.sample(self.seq, 5):
            self.assertTrue(element in self.seq)
 
 
class TestDictValueFormatFunctions(unittest.TestCase):
    def setUp(self):
        self.seq = list(range(10))
 
    def tearDown(self):
        pass
 
    def test_shuffle(self):
        # shuffle sequence
        random.shuffle(self.seq)
        self.seq.sort()
        self.assertEqual(self.seq, list(range(10)))
        # check TypeError exception
        self.assertRaises(TypeError, random.shuffle, (1, 2, 3))
 
 
if __name__ == '__main__':
    # get all test methods start with ‘test’ and return a suite
    suite1 = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions)
    suite2 = unittest.TestLoader().loadTestsFromTestCase(TestCalcFunctions)
    suite3 = unittest.TestLoader().loadTestsFromTestCase(TestDictValueFormatFunctions)
    # please fix another two suite, suite2 of TestCalcFunctions and suite3 of TestDictValueFormatFunctions
 
    # put more test class into suite
    # you can change suites’ order, like [suite1, suite2, suite3]
    suite = unittest.TestSuite([suite2, suite1, suite3])
    # set verbosity = 2 you could get more detailed information
    unittest.TextTestRunner(verbosity=2).run(suite)

 3. unittest skip test

# encoding=utf-8
 
import random, sys, unittest
 
 
class TestSeqFunctions(unittest.TestCase):
    a = 1
    def setUp(self):
        self.seq = list(range(20))
 
    @unittest.skip("skipping")  # skip this method anyway
    def test_shuffle(self):
        random.shuffle(self.seq)
        self.seq.sort()
        self.assertEqual(self.seq, list(range(20)))
        self.assertRaises(TypeError, random.shuffle, (1, 2, 3))
 
    # add a line of annotation thatskip this method if a>5
    # Using skipif() If the condition is true, continue to execute, otherwise skip the decorated test case;
    @unittest.skipIf(a>5, "skipping if a>5")
    def test_choice(self):
        element = random.choice(self.seq)
        self.assertTrue(element in self.seq)
 
    # add a line of annotation that skip if not in linux platform
    # Using skipif() If the condition is true, continue to execute, otherwise skip the decorated test case;
    # Using sys.platform to generate the platform information
    @unittest.skipIf(sys.platform != "linux*", "skipping if not in linux platform")
    def test_sample(self):
        with self.assertRaises(ValueError):
            random.sample(self.seq, 20)
        for element in random.sample(self.seq, 5):
            self.assertTrue(element in self.seq)
 
 
if __name__ == "__main__":
    # unittest.main()
    suite = unittest.TestLoader().loadTestsFromTestCase(TestSeqFunctions)
    suite = unittest.TestSuite(suite)
    unittest.TextTestRunner(verbosity=2).run(suite)

4.unittest Run test under numerical order or alpha order

# encoding=utf-8
 
import unittest
from Calc import Calc
class MyTest(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        print("init Calc before unittest")
        self.c = Calc()
    # Using the test_(number) to sort program from large to small
    def test_1add(self):
        print("run add()")
        self.assertEqual(self.c.add(1, 2, 12), 15, 'test add fail')
 
    def test_2sub(self):
        print("run sub()")
        self.assertEqual(self.c.sub(2, 1, 3), -2, 'test sub fail')
 
    def test_3mul(self):
        print("run mul()")
        self.assertEqual(Calc.mul(1,2, 3, 5), 30, 'test mul fail')
 
    def test_4div(self):
        print("run div()")
        self.assertEqual(Calc.div(1,8, 2, 4), 1, 'test div fail')
 
if __name__ == '__main__':
    unittest.main()

 5.unittest Time Test

import time
import unittest
import timeout_decorator
 
 
class timeoutTest(unittest.TestCase):
 
    # set a time decorator(annotation) which will be triggered after 5s’ running
    # Using the decorator library to stop 5 seconds
    @timeout_decorator.timeout(5)
    def testtimeout(self):
        print("Start")
 
    for i in range(1, 10):
        time.sleep(1)
        print("%d seconds have passed" % i)
 
 
if __name__ == "__main__":
    unittest.main()

Conclusion

 Economical Python-like experiment, self-basic proficiency unittest, other related basic functions, parallel progress completion system application, first step completion actual demand, reduction, waiting progress, research problem