EE308 Lab11

sunshine1211111 2021-12-16 15:06:23

The Link Your Class	https://bbs.csdn.net/forums/MUEE308FZ
The Link of Requirement of This Assignment	https://bbs.csdn.net/topics/603748107
The Aim of This Assignment	Software Testing
MU STU ID and FZU STU ID	19105274-831901203

For today’s experiment , I chose the topic which is related to python.

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 = 0
self.assertNotEqual((b - a), (res), 'assert failed!，%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:
self.assertFalse(1 != 1, "False 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
self.assertIsInstance(type(x), y, "Not an Instance")
except AssertionError as e:
print(e)
if __name__ == '__main__':
# run unittest
unittest.main()

2.unittest test groups

Calc.py

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

TestCalc.py

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
self.assertTrue(self.c.sub(4, 1, 2, 3) == -2)
def test_mul(self):
# fix a line of codes to test c.mul(self, *b) method
self.assertTrue(self.c.mul(3, 4) == 12)
def test_div(self):
# fix a line of codes to test c.div(self, a, *b) method
self.assertTrue(self.c.div(4, 2) == 2)
def tearDown(self):
print("test completed!")
def tearDown(self):
print("tearDown completed")
if __name__ == '__main__':
unittest.main()

unittest_suite.py

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)
# please fix another two suite, suite2 of TestCalcFunctions and suite3 of TestDictValueFormatFunctions
suite2 = unittest.TestLoader().loadTestsFromTestCase(TestCalcFunctions)
# put more test class into suite
suite3 = unittest.TestLoader().loadTestsFromTestCase(TestDictValueFormatFunctions)
# 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 that skip this method if a>5
@unittest.skipIf(a > 5,"skip this method 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
@unittest.skipIf(sys.platform!='linux', "Require for linux")
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()
# P.S.: test case must starts with ‘test’
def test_a_add(self):
print("run add()")
self.assertEqual(self.c.add(1, 2, 12), 15, 'test add fail')
def test_b_sub(self):
print("run sub()")
self.assertEqual(self.c.sub(2, 1, 3), -2, 'test sub fail')
def test_c_mul(self):
print("run mul()")
self.assertEqual(self.c.mul(2, 3, 5), 30, 'test mul fail')
def test_d_div(self):
print("run div()")
self.assertEqual(self.c.div(8, 2, 4), 1, 'test div fail')
if __name__ == '__main__':
unittest.main()

5. unittest Time Test

import sys
import time
import unittest
import timeout_decorator
class timeoutTest(unittest.TestCase):
# set a time decorator(annotation) which will be triggered after 5s’ running
@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

After this experiment, I had such a good use of understanding of some basic knowledge and applications of unit testing. Also had good chance to learn and review the usage of Python.

...全文