20180925-4 单元测试

此作业的要求参见：https://edu.cnblogs.com/campus/nenu/2018fall/homework/2146

单元测试：

单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。

本次四则运算的实现使用了python语言，对于python的单元测试，我参考了下述链接的资料https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143191629979802b566644aa84656b50cd484ec4a7838000

为了编写单元测试，只需要引入Python自带的unittest模块。

单元测试代码

对生成算式、将算式转为逆波兰表达式、计算算式结果3个函数设计如下单元测试：

# -*- coding: utf-8 -*-
import unittest
from f4 import *


class F4Test(unittest.TestCase):
    def test_f4(self):
        pass

    def test01_create_equation(self):           # 测试顺序按函数名字字典顺序进行
        print("create_equation函数单元测试开始：")
        self.assertIsNotNone(create_equation())
        print("OK")
        print("create_equation函数单元测试结束。
")

    def test02_reverse_polish(self):
        eq = []
        print("reverse_polish函数单元测试开始：")
        equation = input("输入一个四则运算（括号请使用英文版的括号）：")
        _eq_ans = input("输入正确的逆波兰表达式：")
        list(equation)          # 输入的表达式是str类型，该函数处理的是含有整型和字符型的list类型
        for temp in equation:
            if '0' <= temp <= '9':
                eq.append(int(temp))
            else:
                eq.append(temp)
        re_equation = reverse_polish(eq)
        str_equation = "".join('%s' % id for id in re_equation)
        self.assertEqual(_eq_ans, str_equation)
        print("OK")
        print("reverse_polish函数单元测试结束。
")

    def test03_calculate(self):
        eq = []
        print("calculate函数单元测试开始：")
        equation = input("输入一个可计算的逆波兰表达式：")
        _eq_ans = input("输入该表达式的正确结果：")
        list(equation)  # 输入的表达式是str类型，该函数处理的是含有整型和字符型的list类型
        for temp in equation:
            if '0' <= temp <= '9':
                eq.append(int(temp))
            else:
                eq.append(temp)
        result = calculate(eq)
        self.assertEqual(float(_eq_ans), result)
        print("OK")
        print("calculate函数单元测试结束。
")


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

测试1（表达式不带括号）：

测试2（表达式包含括号）：

 

测试结果均正确，欢迎使用更多测试用例进行测试。

被测试的源码（f4.py）和单元测试的代码的链接为：https://git.coding.net/Ruidxr/f4.git

create_equation函数：

def create_equation():
    eq = []

    for i in range(3):
        eq.append(random.randint(0, 10))
        eq.append(operator[random.randint(0, 3)])
    eq.append(random.randint(0, 10))
    p = random.randint(1, 5)
    if p is 1:
        eq.insert(0, "(")
        eq.insert(4, ")")
    elif p is 2:
        eq.insert(0, "(")
        eq.insert(6, ")")
    elif p is 3:
        eq.insert(2, "(")
        eq.insert(6, ")")
    elif p is 4:
        eq.insert(2, "(")
        eq.append(")")
    elif p is 5:
        eq.insert(4, "(")
        eq.append(")")
    return eq

 reverse_polish函数：

def reverse_polish(equation):
    result = []
    c = []
    slist = [i for i in equation]

    for item in slist:
        if item in range(0, 100):
            result.append(item)
        elif not c and item in cal.keys():
            c.append(item)
            continue
        elif c and item in cal.keys():
            for x in range(c.__len__()):
                z = c[-1]
                temp = cal[z] if z in cal else cal1[z]
                if temp >= cal[item]:
                    result.append(c.pop())
                else:
                    c.append(item)
                    break
            if not c:
                c.append(item)
        elif item is ")":
            for x in range(c.__len__()):
                if c[-1] == "(":
                    c.pop()
                    break
                else:
                    result.append(c.pop())
        elif item is "(":
            c.append(item)
        # print(result,c)
    for x in range(c.__len__()):
        result.append(c.pop())
    return result

calculate函数：

def calculate(re_equation):
    stack = PyStack()
    sumEnd = 0

    if len(re_equation) is 0:
        return sumEnd
    for i in re_equation:
        if i in range(0, 100):
            stack.push(float(i))
        elif '+' is i:
            a = stack.pop()
            b = stack.pop()
            stack.push(b + a)
        elif '-' is i:
            a = stack.pop()
            b = stack.pop()
            stack.push(b - a)
        elif '*' is i:
            a = stack.pop()
            b = stack.pop()
            stack.push(b * a)
        elif '÷' is i:
            a = stack.pop()
            b = stack.pop()
            if a is 0:
                return False             #print('%d/%d分子不能为0' % (b, a))
            else:
                stack.push(b / a)
    return stack.pop()