EE308_LAB11

Preparation

Learn related knowledge about Junit Test for Java and Unittest for python. You can finish the following assignment or test Your Project.

#in this lab, I use Python to test code

Task

1. Here are Junit Test task and Unittest task for choose. If you are good at Java , we suggest you choose the first one, if you are good at Python, then, the latter one.
2. Follow the requests and tips, complete the test task .

Requirements

1. You should be familiar with Junit Test or Unittest and the usage of these tools. Such as ‘assert, suite, timeout’, check problems for detail.
2. Fix the missing codes according to requirement for every problem.

Test code

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 return_None(self):
        return one

# 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 = 3
            self.assertEqual(a - b, res, 'assert failed!，%s - %s != %s' %(a, b, sum))
        except AssertionError as e:
            print (e)

# 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 = 3
            self.assertEqual(a - b, res, 'assert failed!，%s - %s != %s' %(a, b, sum))
        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.assertTrue(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.assertIs(type(x),type(y), "%s and %s are not same" %(a, b))
 
        except AssertionError as e:
            print (e)
 
if __name__ == '__main__':
    # run unittest
    unittest.main()

 unittest test groups

# 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.assertTrue(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.assertIs(type(x),type(y), "%s and %s are not same" %(a, b))
 
        except AssertionError as e:
            print (e)
 
if __name__ == '__main__':
    # run unittest
    unittest.main()

#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(10,5,3)==2)
 
    def test_mul(self):
        # fix a line of codes to test c.mul(self, *b) method
        self.assertTrue(self.c.mull(1,2,3)==6)
 
    def test_div(self):
        # fix a line of codes to test c.div(self, a, *b) method
        self.assertTrue(self.c.div(6,3,2)==1)
 
    def tearDown(self):
        print ("test completed!")
 
    def tearDown(self):
        print ("tearDown completed")

# 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)
    suite3 = unittest.TestLoader().loadTestsFromTestCase(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 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,”Don’t run”)
      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(platform.system().lower != ‘linux’,”Don’t run”) 
      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)

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()
 
	# rename the four methods bellow, make sure print queue will be :
 
    # P.S.: test case must starts with ‘test’ 
    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(self.c.mul(2, 3, 5), 30, 'test mul fail')
 
    def test_4div(self):
        print ("run div()")
        self.assertEqual(self.c.div(8, 2, 4), 1, 'test div fail')
 
if __name__ == '__main__':
    unittest.main()

unittest Time Test

import time
import timeout_decorator
import unittest
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

In this Lab, I learned how to use "unittest" to test code which we wrote. It is an interesting thing to use code to test code. I think code test is a new experience for me through It is not easy for me but worth learning and experiencing.