class TestCalc:
def setup_class(self):
print("开始计算")
self.calc = Calculator()
def teardown_class(self):
print("计算结束")
@pytest.mark.run(order=1) #改变执行顺序：加-减-乘-除
# 1-3)-1:加法：测试数据的数据驱动的测试用例
@pytest.mark.parametrize('a,b,expect', get_datas()[0], ids=get_datas()[1])
def test_add(self, a, b, expect):
result = self.calc.add(a, b)
assert result == expect
@pytest.mark.parametrize('a,b,expect', [[0.1, 0.1, 0.2], [0.1, 0.2, 0.3]])
@pytest.mark.run(order=2)
def test_add_float(self, a, b, expect):
result = self.calc.add(a, b)
assert round(result, 2) == expect
@pytest.mark.run(order=-2)
# 1-3)-2:除法：测试数据的数据驱动的测试用例
@pytest.mark.parametrize('a,b,expect', get_datas()[6], ids=get_datas()[7])
def test_div(self, a, b, expect):
result = self.calc.div(a, b)
assert result == expect
@pytest.mark.run(order=-1)
def test_div_zero(self):
with pytest.raises(ZeroDivisionError):
result = self.calc.div(1, 0)
@pytest.mark.run(order=3)
# 1-3)-3:减法：测试数据的数据驱动的测试用例
@pytest.mark.parametrize('a,b,expect', get_datas()[2], ids=get_datas()[3])
def test_sub(self, a, b, expect):
result = self.calc.sub(a, b)
assert result == expect
@pytest.mark.run(order=4)
# 1-3)-4:乘法：测试数据的数据驱动的测试用例
@pytest.mark.parametrize('a,b,expect', get_datas()[4], ids=get_datas()[5])
def test_mul(self, a, b, expect):
result = self.calc.mul(a, b)
assert result == expect
@pytest.mark.run(order=5)
@pytest.mark.parametrize('a,b,expect',
[[0.3, 0.1, 0.03], [0.9, 0.99, 0.891]])
def test_mul_float(self, a, b, expect):
result = self.calc.mul(a, b)
assert round(result, 3) == expect
class TestMul:
def setup_class(self):
self.cal = Calculator()
@pytest.mark.parametrize("a,b,expect", get_data()["mul_data"]["int"])
def test_mul_int(self, a, b, expect):
result = self.cal.mul(a, b)
assert (result) == expect
@pytest.mark.parametrize("a,b,expect", get_data()["mul_data"]["float"])
def test_mul_float(self, a, b, expect):
result = self.cal.mul(a, b)
assert (round(result, 2)) == expect
class TestCalc:
def setup_class(self):
self.cal = Calculator()
print("开始计算")
def teardown_class(self):
print("计算结束")
@pytest.mark.parametrize("a,b,expect", [(3, 5, 8), (-1, -2, -3),
(100, 200, 300)],
ids=["int", "minus", "bigint"])
def test_add(self, a, b, expect):
assert expect == self.cal.add(a, b)
@pytest.mark.parametrize("a,b,expect", [(4, 8, -4), (-6, -5, -1),
(99, 108, -9)],
ids=["int", "minus", "bigint"])
def test_sub(self, a, b, expect):
assert expect == self.cal.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(4, 8, 32), (-6, -5, 30),
(99, 108, 10692)],
ids=["int", "minus", "bigint"])
def test_mul(self, a, b, expect):
assert expect == self.cal.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(60, 5, 12), (-6, -5, 1.2),
(500, 100, 5)],
ids=["int", "minus", "bigint"])
def test_div(self, a, b, expect):
assert expect == self.cal.div(a, b)
class TestCal(Calculator):
def setup(self):
self.calc = Calculator()
@pytest.mark.parametrize("a, b, expect",
get_datas()[0],
ids=get_datas()[1])
def test_add(self, a, b, expect):
result = self.calc.add(a, b)
assert result == expect
@pytest.mark.flaky(reruns=3, reruns_dalay=5)
def test_sub(self):
result = self.calc.sub(5, 3)
assert result == 5
def test_mul(self):
result = self.calc.mul(3, 7)
assert result == 21
def test_div(self):
result = self.calc.div(6, 2)
assert result == 3
def test_add_steps(self):
a = 1
b = 2
expect = 3
# assert 2 == self.calc.add(1, 1)
# assert 3 == self.calc.add1(1, 2)
# assert 0 == self.calc.add(-1, 1)
steps(self.calc, a, b, expect)
class TestCalc:
def setup_method(self):
print("\nsetup_method:调用方法开始计算")
def teardown_method(self):
print("\nteardown_method:方法调用完成计算结束")
def setup_class(self):
self.calc = Calculator()
@pytest.mark.parametrize("a,b,expect", get_datas()["add"])
def test_add(self, a, b, expect):
result = self.calc.add(a, b)
print(result)
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datas()["sub"])
def test_sub(self, a, b, expect):
result = self.calc.sub(a, b)
print(result)
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datas()["mul"])
def test_mul(self, a, b, expect):
result = self.calc.mul(a, b)
print(result)
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datas()["div"])
def test_div(self, a, b, expect):
result = self.calc.div(a, b)
print(result)
assert result == expect
class TestCalc:
# 因为生成实例是下面方法都需要生成的，可以抽离出来setup，使得代码不冗余
def setup_class(self):
self.cal = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
@pytest.mark.parametrize("a,b,expected", [(3, 5, 8), (-1, -2, -3),
(1000, 1000, 2000)],
ids=["中文add1", "add2", "add3"])
def test_add(self, a, b, expected):
assert expected == self.cal.add(a, b)
@pytest.mark.parametrize("a,b,expect", [(3, 5, -2), (99, 44, 55)],
ids=["sub1", "sub2"])
def test_sub(self, a, b, expect):
assert expect == self.cal.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(3, 5, 15), (99, 2, 198)],
ids=["mul1", "mul2"])
def test_mul(self, a, b, expect):
assert expect == self.cal.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(10, 5, 2), (99, 2, 49.5)],
ids=["div1", "div2"])
def test_div(self, a, b, expect):
assert expect == self.cal.div(a, b)
class TestCalc:
def setup_class(self):
self.calc = Calculator()
def setup_method(self):
print("开始计算")
def teardown_method(self):
print("结束计算")
@pytest.mark.parametrize("a,b,expect", [(3, 5, 8), (-1, -2, -3),
(1000, 1000, 2000)],
ids=["int", "minus", "bigint"])
def test_add(self, a, b, expect):
assert self.calc.add(a, b) == expect
@pytest.mark.parametrize("a,b,expect", [(5, 3, 2), (-3, -1, -2),
(1000, 800, 200)],
ids=["int", "minus", "bigint"])
def test_sub(self, a, b, expect):
assert self.calc.sub(a, b) == expect
@pytest.mark.parametrize("a,b,expect", [(1, 2, 2), (-5, -6, 30),
(2000, 3000, 6000000)],
ids=["int", "minus", "bigint"])
def test_mul(self, a, b, expect):
assert self.calc.mul(a, b) == expect
@pytest.mark.parametrize("a, b, expect", [(6, 2, 3), (-50, -5, 10),
(10000, 1000, 10)],
ids=["int", "minus", "bigint"])
def test_divide(self, a, b, expect):
assert self.calc.divide(a, b) == expect
class TestCalc:
#self.cal = Calculator()在类下面的方法中都要用到，如果每个方法里面都写入这一句会很麻烦，所以在类的开始只执行一次，然后在方法里面调用即可
def setup_class(self):
self.cal = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
def setup_method(self):
print("setup:开始执行测试用例")
def teardown_method(self):
print("teardown:结束执行测试用例")
@pytest.mark.parametrize("a,b,expect",[(3,5,8),(-1,-2,-3),(100,300,400)],ids=["interesting","minus","bigint"])
def test_add(self,a,b,expect):
assert expect == self.cal.add(a,b)
@pytest.mark.parametrize("a,b,expect",[(6,3,3),(-8,-2,-6),(300,100,200)],ids=["interesting","minus","bigint"])
def test_sub(self, a, b, expect):
assert expect == self.cal.sub(a,b)
@pytest.mark.parametrize("a,b,expect", [(3,2,6), (-2,-5,10), (100,100,10000)],ids=["interesting", "minus", "bigint"])
def test_mul(self,a,b,expect):
assert expect == self.cal.mul(a,b)
@pytest.mark.parametrize("a,b,expect", [(10,2,5), (-8, -2, 4), (300, 100, 3)],ids=["interesting", "minus", "bigint"])
def test_div(self,a,b,expect):
assert expect == self.cal.div(a,b)
class TestCalc:
def setup_class(self):
self.cal = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
@pytest.mark.parametrize("a,b,expect", [(3, 5, 8), (-1, -2, -3),
(100, 300, 400)],
ids=["int", "minus", "bigint"])
def test_add(self, a, b, expect):
assert expect == self.cal.add(a, b)
@pytest.mark.parametrize("a,b,expect", [(3, 5, -2), (-1, -2, 1),
(100, 300, -200)],
ids=["int", "minus", "bigint"])
def test_sub(self, a, b, expect):
assert expect == self.cal.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(3, 5, 15), (-1, -2, 2),
(100, 300, 30000)],
ids=["int", "minus", "bigint"])
def test_mul(self, a, b, expect):
assert expect == self.cal.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(3, 5, 0.6), (-1, -2, 0.5),
(100, 50, 2.0)],
ids=["int", "minus", "bigint"])
def test_mod(self, a, b, expect):
assert expect == self.cal.mod(a, b)
class TestCalc:
def setup_class(self):
self.calc = Calculator()
@pytest.mark.parametrize("a,b,expect", get_datas()[0])
def test_add(self, a, b, expect):
# 调用add函数,返回的结果保存在result里面
result = self.calc.add(a, b)
# 判断result结果是否等于期望的值
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datas()[1])
def test_sub(self, a, b, expect):
result = self.calc.sub(a, b)
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datas()[2])
def test_mul(self, a, b, expect):
result = self.calc.mul(a, b)
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datas()[3])
def test_div(self, a, b, expect):
result = self.calc.div(a, b)
assert result == expect
class TestCalc:
def setup_class(self):
self.cal = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
@pytest.mark.run(order=2)
@pytest.mark.parametrize("a,b,expect", get_datas()[0], ids=get_datas()[4])
def test_add(self, a, b, expect, myfixture):
assert expect == self.cal.add(a, b)
@pytest.mark.parametrize("a,b,expect", get_datas()[1], ids=get_datas()[4])
@pytest.mark.run(order=1)
def test_sub(self, a, b, expect, myfixture):
assert expect == self.cal.sub(a, b)
@pytest.mark.parametrize("a,b,expect", get_datas()[2], ids=get_datas()[4])
def test_mul(self, a, b, expect):
assert expect == self.cal.mul(a, b)
@pytest.mark.parametrize("a,b,expect", get_datas()[3], ids=get_datas()[4])
def test_mod(self, a, b, expect):
assert expect == self.cal.mod(a, b)
class TestCalc():
def setup_class(self):
self.calc = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
@pytest.mark.parametrize("a,b,expect", [(3, 5, 8), (-1, -2, -3),
(100, 300, 400)],
ids=["int", "minus", "bigint"])
def test_add(self, a, b, expect):
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize("a,b,expect", [(5, 3, 2), (-5, -2, -3),
(300, 200, 100)],
ids=["int", "minus", "bigint"])
def test_sub(self, a, b, expect):
assert expect == self.calc.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(2, 5, 10), (2.5, 4, 10),
(100, 200, 20000)],
ids=["int", "minus", "bigint"])
def test_mul(self, a, b, expect):
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(10, 2, 5), (6.2, 2, 3.1),
(2000, 20, 100)],
ids=['int', 'float', 'bigint'])
def test_div(self, a, b, expect):
assert expect == self.calc.div(a, b)
class TestCal:
def setup_class(self):
print("\n开始计算")
# 实例化计算器的类
self.cal = Calculator()
def teardown_class(self):
print("\n结束计算")
@pytest.mark.parametrize('a,b,exp', datas['add'], ids=ids['add'])
def test_add(self, a, b, exp):
res = self.cal.add(a, b)
assert res == exp
@pytest.mark.parametrize('a,b,exp', datas['sub'], ids=ids['sub'])
def test_sub(self, a, b, exp):
res = self.cal.sub(a, b)
assert res == exp
@pytest.mark.parametrize('a,b,exp', datas['mul'], ids=ids['mul'])
def test_mul(self, a, b, exp):
res = self.cal.mul(a, b)
assert res == exp
@pytest.mark.parametrize('a,b,exp', datas['div'], ids=ids['div'])
def test_div(self, a, b, exp):
res = self.cal.div(a, b)
assert res == exp
class TestCalc:
def setup_class(self):
self.calc = Calculator()
print('【开始计算】')
def teardown_class(self):
print('【计算结束】')
@pytest.mark.parametrize('a,b,expect', [(3, 5, 8), (-1, -2, -3),
(100, 300, 400)],
ids=['int', 'minus', 'bigint'])
def test_add(self, a, b, expect):
# cal=Calculator()
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize('a,b,expect', [(5, 4, 1), (200, 100, 100),
(10, 6, 4)])
def test_sub(self, a, b, expect):
# cal=Calculator() #与上方add都用了调用计算函数，抽取出来放至setup
assert expect == self.calc.sub(a, b)
@pytest.mark.parametrize('a,b,expect', [(5, 4, 20), (20, 10, 200),
(10, 6, 60)])
def test_mul(self, a, b, expect):
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize('a,b,expect', [(8, 4, 2), (200, 100, 2),
(10, 2, 5)])
def test_div(self, a, b, expect):
assert expect == self.calc.div(a, b)
class TestCalc():
def setup_class(self):
self.calc = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
@pytest.mark.parametrize("a,b,expect", get_datas()[0], ids=get_datas()[1])
def test_add(self, a, b, expect, myfixture):
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize("a,b,expect", [(1, 1, 0), (-3, -2, -1),
(1000, 2000, -1000)],
ids=["int", "minus", "bigint"])
def test_sub(self, a, b, expect):
assert expect == self.calc.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(1, 1, 1), (-3, -2, 6),
(1000, 2, 2000)],
ids=["int", "minus", "bigint"])
def test_mul(self, a, b, expect):
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(1, 1, 1), (-6, -3, 2),
(1000, 500, 2)],
ids=["int", "minus", "bigint"])
def test_div(self, a, b, expect, myfixture):
# self.calc = Calculator()
assert expect == self.calc.div(a, b)
class TestCalc:
def setup(self):
print("开始计算")
def teardown(self):
print("关闭计算")
def setup_class(self):
self.clc = Calculator()
@pytest.mark.parametrize("a,b,hopevalue",get_datas("add_datas"),ids=get_datas("myids"))
def test_add(self,a,b,hopevalue):
#加法测试
result = self.clc.add(a,b)
assert result == hopevalue
@pytest.mark.parametrize("a,b,hopevalue",get_datas("sub_datas"),ids=get_datas("myids"))
def test_sub(self,a,b,hopevalue):
#减法测试
result = self.clc.sub(a,b)
assert result == hopevalue
@pytest.mark.parametrize("a,b,hopevalue", get_datas("mul_datas"),
ids=get_datas("myids"))
def test_mul(self, a, b, hopevalue):
#乘法测试
result = self.clc.mul(a, b)
assert result == hopevalue
@pytest.mark.parametrize("a,b,hopevalue", get_datas("div_datas"),
ids=get_datas("myids"))
def test_div(self, a, b, hopevalue):
#除法测试
result = self.clc.div(a, b)
assert result == hopevalue
class TestCase():
def setup_class(self):
self.calc = Calculator()
def teardown_class(self):
pass
@pytest.mark.run(order=1)
@pytest.mark.parametrize("a,b,expect",*read_yaml("add"))
def test_add(self, a, b, expect):
result = self.calc.add(a, b)
assert result == expect
@pytest.mark.run(order=2)
@pytest.mark.parametrize("a,b,expect",*read_yaml("sub"))
def test_sub(self, a, b, expect):
result = self.calc.sub(a, b)
assert result == expect
@pytest.mark.run(order=3)
@pytest.mark.parametrize("a,b,expect",*read_yaml("mul"))
def test_mul(self, a, b, expect):
result = self.calc.mul(a, b)
assert result == expect
@pytest.mark.run(order=4)
@pytest.mark.parametrize("a,b,expect",*read_yaml("div"))
def test_div(self, a, b, expect):
result = self.calc.div(a, b)
assert result == expect
class TestCalculator:
def setup_class(self):
print("start")
self.cal = Calculator()
@pytest.mark.parametrize("a, b, excepted", [(1, 2, 3), (-1, 1, 0),
(1.03, 1.23, 2.26)])
def test_add(self, a, b, excepted):
print("add")
assert self.cal.add(a, b) == excepted
@pytest.mark.parametrize("a, b, excepted",
yaml.safe_load(open("./data.yml"))["data"])
def test_sub(self, a, b, excepted):
print("sub")
print(yaml.safe_load(open("./data.yml"))["data"])
res = self.cal.sub(a, b)
if isinstance(res, float):
res = round(res, 2)
assert res == excepted
@pytest.mark.parametrize("a, b, excepted",
yaml.safe_load(open("./data.yml"))["mul"])
def test_mul(self, a, b, excepted):
print("mul")
print(yaml.safe_load(open("./data.yml"))["mul"])
assert self.cal.mul(a, b) == excepted
@pytest.mark.parametrize("a, b, excepted",
yaml.safe_load(open("./data.yml"))["div"],
ids=yaml.safe_load(open("./data.yml"))["divids"])
def test_dev(self, a, b, excepted):
print("div")
print(yaml.safe_load(open("./data.yml"))["div"])
assert self.cal.div(a, b) == excepted
class TestCalc:
def setup_class(self):
self.calc = Calculator()
print('Start calculation...')
def teardown_class(self):
print('End calculation')
@pytest.mark.parametrize('a,b,expect', [(3, 5, 8), (-1, -2, -3),
(100, 300, 500)],
ids=['int', 'minus', 'bigint'])
def test_add(self, a, b, expect):
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize('a,b,expect', [(3, 5, -2), (-1, -2, 1),
(300, 300, 10)],
ids=['int', 'minus', 'bigint'])
def test_minus(self, a, b, expect):
assert expect == self.calc.minus(a, b)
@pytest.mark.parametrize('a,b,expect', [(3, 5, 12), (-1, -2, 2),
(300, 4, 1200)],
ids=['int', 'minus', 'bigint'])
def test_mul(self, a, b, expect):
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize('a,b,expect', [(3, 5, 0.6), (-4, -2, 2),
(400, 100, 3)],
ids=['int', 'minus', 'bigint'])
def test_div(self, a, b, expect):
assert expect == self.calc.div(a, b)
class TestCalc:
# 因为生成实例是下面方法都需要生成的，可以抽离出来setup，使得代码不冗余
def setup_class(self):
self.cal = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
@pytest.mark.parametrize("a,b,expected", yaml.safe_load(open("./homework2.yml"))["add"])
def test_add(self, a, b, expected):
assert expected == self.cal.add(a, b)
# @pytest.mark.parametrize("a,b,expect", [(3, 5, -2), (99, 44, 55)], ids=["sub1", "sub2"])
@pytest.mark.parametrize("a,b,expected", yaml.safe_load(open("./homework2.yml"))["sub"],
ids=yaml.safe_load(open("./homework2.yml"))["sub_name"])
def test_sub(self, a, b, expect):
assert expect == self.cal.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(3, 5, 15), (99, 2, 198)], ids=["mul1", "mul2"])
def test_mul(self, a, b, expect):
assert expect == self.cal.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(10, 5, 2), (99, 2, 49.5)], ids=["div1", "div2"])
def test_div(self, a, b, expect):
assert expect == self.cal.div(a, b)
class TestCalc:
def setup_class(self):
self.calc = Calculator()
print("开始计算")
def teardown_class(self):
print("结束计算")
@pytest.mark.parametrize("a,b,expect", [(3, 5, 8), (-1, -2, -3),
(100, 300, 400)],
ids=["int", "minus", "bigint"])
def test_add(self, a, b, expect):
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize("a,b,expect", [(10, 1, 9), (0, 0, 0),
(-1, -1, 0)],
ids=["int", "minus", "bigint"])
def test_sub(self, a, b, expect):
assert expect == self.calc.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(0.1, 1000, 100),
(100, 100, 10000), (-1, -1, 1)],
ids=["int", "minus", "bigint"])
def test_mul(self, a, b, expect):
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(10, 4, 2.5), (0, 100, 0),
(1000, 1, 1000)],
ids=["int", "minus", "bigint"])
def test_mul(self, a, b, expect):
assert expect == self.calc.div(a, b)
class TestCalc():
# calc = Calculator()
def setup_class(self):
print("计算开始")
self.calc = Calculator()
def teardown_class(self):
print("计算结束")
@pytest.mark.parametrize(
'a,b,c', [[1, 1, 2], [100, 100, 200], [1 / 3, 4 / 7, 19 / 21],
[-1, -2, -3], [1, 0, 1]],
ids=[
'int_case', 'bigNum_case', 'float_case', 'minus_case', 'zero_case'
])
def test_add(self, a, b, c):
result = self.calc.add(a, b)
assert result == round(c, 2)
def test_add1(self):
test_data = [[1, 2, 3], [100, 1000, 1100], [0.56, 0.67, 1.23],
[-3, -4.5, -7.5], [0, 3, 3]]
# print (test_data[1])
for i in range(0, len(test_data)):
result = self.calc.add(test_data[i][0], test_data[i][1])
assert result == test_data[i][2]
def test_sub(self):
result = self.calc.sub(3, 1)
assert result == 2
def test_mul(self):
result = self.calc.mul(3, 3)
assert result == 9
##方法round
@pytest.mark.parametrize(
'e,d,f', [[4, 2, 2], [0.1, 0.1, 1], [0, 5, 0], [1, 0, 3], [1, 3, 0.33],
[2, 3, 0.67]],
ids=[u'整数相处', u'小数相除', u'分子为零', u'分母为零', u'不四舍五入', u'四舍五入'])
def test_div(self, e, d, f):
result = self.calc.div(e, d)
assert result == f
##Decimal
@pytest.mark.parametrize(
'e,d,f', [[4, 2, 2], [0.1, 0.1, 1], [0, 5, 0], [1, 0, 3], [1, 3, 0.33],
[2, 3, 0.67]],
ids=[u"整数相处", u"小数相除", u'分子为零', u'分母为零', u'不四舍五入', u'四舍五入'])
def test_div(self, e, d, f):
result = self.calc.div1(e, d)
assert result == Decimal(f).quantize(Decimal('0.00'))
def a(self):
b = get_datas()
print(b)
class TestCalc:
# 资源准备
def setup_class(self):
print("计算开始")
# 实例化被测类
self.calc = Calculator()
# 资源销毁
def teardown_class(self):
print("计算结束")
# 加法
@pytest.mark.parametrize(
'a,b,expect',
[[1, 1, 2], [100, 100, 200], [0.1, 0.1, 0.2], [-1, -1, -2], [1, 0, 1]],
ids=[
'int_case', 'bignum_case', 'float_case', 'minus_case', 'zero_case'
])
def test_add(self, a, b, expect):
# calc = Calculator()
result = self.calc.add(a, b)
assert result == expect
# 减法
@pytest.mark.parametrize(
'a,b,expect',
[[1, 1, 0], [200, 100, 100], [0.2, 0.1, 0.1], [-1, -1, 0], [0, 0, 0]],
ids=[
'int_case', 'bignum_case', 'float_case', 'Minus_case', 'zero_case'
])
def test_sub(self, a, b, expect):
result = self.calc.sub(a, b)
assert result == expect
# 乘法
@pytest.mark.parametrize(
'a,b,expect',
[[1, 1, 1], [200, 100, 20000], [0.2, 1, 0.2], [-1, -1, 1], [0, 0, 0]],
ids=[
'int_case', 'bignum_case', 'float_case', 'Minus_case', 'zero_case'
])
def test_mul(self, a, b, expect):
result = self.calc.mul(a, b)
assert result == expect
# 除法
@pytest.mark.parametrize(
'a,b,expect', [[1, 1, 1], [200, 100, 2], [0.2, 1, 0.2], [-1, -1, 1],
[5, 0, '除数不能为0']],
ids=['整数测试用例', 'bignum_case', 'float_case', 'Minus_case', 'zero_case'])
def test_div(self, a, b, expect):
if b == 0:
print("除数不能为0！")
else:
result = self.calc.div(a, b)
assert result == expect
class TestCalc:
def setup_class(self):
# 实例化类,生成类的对象
self.calc = Calculator()
def setup_method(self):
log.logger.debug("\nsetup_module:【开始计算】")
def teardown_method(self):
log.logger.debug("\nsetup_module:【结束计算】")
# 使用参数化
@pytest.mark.parametrize("a,b,expect",
get_datas()[0][0],
ids=get_datas()[1][0])
# 测试add函数
def test_add(self, a, b, expect):
# 调用add函数,返回的结果保存在result里面
result = self.calc.add(a, b)
# 判断result结果是否等于期望的值
assert result == expect
log.logger.debug({f"预期结果：{result}"})
# 测试sub函数
@pytest.mark.parametrize("a,b,expect",
get_datas()[0][1],
ids=get_datas()[1][1])
def test_sub(self, a, b, expect):
# 调用sub函数，返回的结果保存在result里面
result = self.calc.sub(a, b)
assert result == expect
log.logger.debug({f"预期结果：{result}"})
# 测试mul函数
@pytest.mark.parametrize("a,b,expect",
get_datas()[0][2],
ids=get_datas()[1][2])
def test_mul(self, a, b, expect):
# 调用mul函数，返回的结果保存在result里面
result = self.calc.mul(a, b)
assert result == expect
log.logger.debug({f"预期结果：{result}"})
# 测试div函数
@pytest.mark.parametrize("a,b,expect",
get_datas()[0][3],
ids=get_datas()[1][3])
def test_div(self, a, b, expect):
# 调用div函数，返回的结果保存在result里面
result = self.calc.div(a, b)
assert result == expect
log.logger.debug({f"预期结果：{result}"})
class TestCalc():
def setup_class(self):
self.calc = Calculator()
print("测试开始")
def teardown_class(self):
print("测试结束")
@pytest.mark.parametrize("a,b,expect",
[[1, 1, 2], [100, 1, 200], [0.1, 0.1, 0.2],
[-1, -1, -2], [1, 0.5, 1.5]],
ids=[
'int_case_pass', 'int_case_fail',
'float_case_pass', 'minus_case_pass',
'zero_case_pass'
])
def test_add(self, a, b, expect):
result = self.calc.add(a, b)
print(123123121)
assert result == expect
@pytest.mark.parametrize(
"a,b,expect",
[[1, 2, 3], [100, 200, 300], [0.1, 0.1, 0.2], [-1, -2, -3], [1, 0, 1]],
ids=[
'int_case', 'bignum_case', 'float_case', 'minus_case', 'zero_case'
])
def test_sub(self, a, b, expect):
result = self.calc.sub(a, b)
assert result == expect
@pytest.mark.parametrize("a,b,expect",
[[1, 2, 2], [300, 400, 120000], [0.1, 0.9, 0.09],
[-1, -3, 3], [4, 0, 0]],
ids=[
'int_case', 'bignum_case', 'float_case',
'minus_case', 'zero_case'
])
def test_mul(self, a, b, expect):
result = self.calc.mul(a, b)
assert result == expect
@pytest.mark.parametrize("a,b,expect",
[[4, 2, 2], [1000, 200, 5], [0.9, 0.3, 3],
[-9, -3, 3], [9, 0, '除数不能为0'], [0, 9, 0]],
ids=[
'int_case', 'bignum_case', 'float_case',
'minus_case', 'zero_1_case', 'zero_1_case'
])
def test_div(self, a, b, expect):
result = self.calc.div(a, b)
assert result == expect
class Testcalcu():
def setup_class(self):
self.cal=Calculator()
def teardown_class(self):
print('计算器类测试结束')
@pytest.mark.parametrize('a,b,expect',[(1,1,2),(-1,-2,-3),(0.5,0.1,0.6)],ids=['+','-','.'])
def test_add(self,a,b,expect):
assert self.cal.add(a,b)==expect
@pytest.mark.parametrize('a,b,expect', [(1, 1, 0), (-1, -2, 1), (0.5, 0.1, 0.4)], ids=['+', '-', '.'])
def test_sub(self,a,b,expect):
assert self.cal.sub(a,b)==expect
@pytest.mark.parametrize('a,b,expect', [(1, 1, 1), (-1, -2, 2), (0.5, 0.1, 0.05)], ids=['+', '-', '.'])
def test_mul(self,a,b,expect):
assert self.cal.mul(a,b)==expect
@pytest.mark.parametrize('a,b,expect', [(1, 1, 1), (-1, -2, 0.5), (0.5, 0.1, 5)], ids=['+', '-', '.'])
def test_div(self,a,b,expect):
assert self.cal.div(a,b)==expect
class TestCalc:
def setup_method(self):
print("\n开始计算")
def teardown_method(self):
print("\n结束计算")
def setup_class(self):
# 实例化类,生成类的对象
self.calc = Calculator()
# 使用参数化
@pytest.mark.parametrize("a,b,expect", get_datax()[0], ids=get_datax()[1])
# 测试add函数
def test_add(self, a, b, expect):
# 调用add函数,返回的结果保存在result里面
result = self.calc.add(a, b)
# 判断result结果是否等于期望的值
assert result == expect
# 使用参数化
@pytest.mark.parametrize("a,b,expect", get_datax()[2], ids=get_datax()[3])
# 测试sub函数
def test_sub(self, a, b, expect):
# 调用sub函数,返回的结果保存在result里面
result = self.calc.sub(a, b)
# 判断result结果是否等于期望的值
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datax()[4], ids=get_datax()[5])
# 测试sub函数
def test_mul(self, a, b, expect):
# 调用mul函数,返回的结果保存在result里面
result = self.calc.mul(a, b)
# 判断result结果是否等于期望的值
assert result == expect
@pytest.mark.parametrize("a,b,expect", get_datax()[6], ids=get_datax()[7])
# 测试sub函数
def test_div(self, a, b, expect):
# 调用div函数,返回的结果保存在result里面
result = self.calc.div(a, b)
# 判断result结果是否等于期望的值
assert result == expect
class TestCal:
def setup_class(self):
self.calc = Calculator()
print("开始测试：加、减、乘、除")
def teardown_class(self):
print("加、减、乘、除 的测试结束")
def setup_method(self):
print("开始计算")
def teardown_method(self):
print("计算结束\n")
@pytest.mark.parametrize("a,b,expect",
get_datas()["add_datas"],
ids=get_datas()["my_addid"])
def test_add(self, a, b, expect):
print(f"加运算：{a} + {b} = {expect}")
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize("a,b,expect",
get_datas()["sub_datas"],
ids=get_datas()["my_subid"])
def test_sub(self, a, b, expect):
print(f"减运算：{a} - {b} = {expect}")
assert expect == self.calc.sub(a, b)
@pytest.mark.parametrize("a,b,expect",
get_datas()["mul_datas"],
ids=get_datas()["my_mulid"])
def test_mul(self, a, b, expect):
print(f"乘运算：{a} * {b} = {expect}")
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize("a,b,expect",
get_datas()["div_datas"],
ids=get_datas()["my_divid"])
def test_div(self, a, b, expect):
print(f"除运算：{a} / {b} = {expect}")
if b != 0:
assert expect == self.calc.div(a, b)
else:
print("除数不能为0")
class TestCal:
def setup_class(self):
self.calc = Calculator()
print("开始测试：加、减、乘、除")
def teardown_class(self):
print("加、减、乘、除 的测试结束")
def setup_method(self):
print("开始计算")
def teardown_method(self):
print("计算结束\n")
@pytest.mark.parametrize("a,b,expect", [(0, 1, 1), (3, 5, 8), (-1, -1, -2),
(1000, 1000, 2000)],
ids=["zero", "int", "mius", "bigint"])
def test_add(self, a, b, expect):
print(f"加运算：{a} + {b} = {expect}")
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize("a,b,expect", [(5, 0, 5), (2, 1, 1), (-5, -1, -4),
(20000, 9999, 10001)],
ids=["zero", "int", "mius", "bigint"])
def test_sub(self, a, b, expect):
print(f"减运算：{a} - {b} = {expect}")
assert expect == self.calc.sub(a, b)
@pytest.mark.parametrize("a,b,expect", [(1, 0, 0), (1, 1, 1), (-1, -1, 1),
(2021, 2000, 4042000)],
ids=["zero", "int", "mius", "bigint"])
def test_mul(self, a, b, expect):
print(f"乘运算：{a} * {b} = {expect}")
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize("a,b,expect", [(1, 0, 0), (0, 9, 0), (1, 1, 1),
(-100, -2, 50), (10000, 100, 100)],
ids=["zero", "zero1", "int", "mius", "bigint"])
def test_div(self, a, b, expect):
print(f"除运算：{a} / {b} = {expect}")
if b != 0:
assert expect == self.calc.div(a, b)
else:
print("除数不能为0")
class TestCalc:
def setup_class(self):
# 实例化类,生成类的对象
self.calc = Calculator()
print("\nsetup_class:所有计算开始")
def setup_method(self):
print("\nsetup_method:计算开始")
def teardown_method(self):
print("\nteardown_method:计算结束")
def teardown_class(self):
print("\nteardown_class:所有计算结束")
# 使用参数化
@pytest.mark.parametrize("a,b,expect",
yaml.safe_load(open("./data.yml"))["datas"])
# 测试add函数
def test_add(self, a, b, expect):
# 调用add函数,返回的结果保存在result里面
result = self.calc.add(a, b)
# 判断result结果是否等于期望的值
assert result == expect
@pytest.mark.parametrize("a,b,expect",
yaml.safe_load(open("./data.yml"))["sub"])
def test_sub(self, a, b, expect):
result1 = self.calc.sub(a, b)
assert result1 == expect
@pytest.mark.parametrize("a,b,expect",
yaml.safe_load(open("./data.yml"))["mul"])
def test_mul(self, a, b, expect):
result2 = self.calc.mul(a, b)
assert result2 == expect
@pytest.mark.parametrize("a,b,expect",
yaml.safe_load(open("./data.yml"))["div"])
def test_div(self, a, b, expect):
result3 = self.calc.div(a, b)
assert result3 == expect
