class CalcTest(unittest.TestCase):
"""四则运算程序测试用例"""
def setUp(self):
self.cal = Calc(4, 5)
def tearDown(self):
print('\nTestcase Finish.')
def test_add(self):
result = self.cal.add()
self.assertEqual(result, 9)
def test_sub(self):
result = self.cal.sub()
self.assertEqual(result, -1)
def test_mul(self):
result = self.cal.mul()
self.assertEqual(result, 20)
def test_div(self):
result = self.cal.div()
self.assertEqual(result, 0.8)
def test_div_except(self):
self.cal = Calc(4, 0)
self.assertRaises(TypeError)
def test_correct_derivative_str_and_integer(self, mock):
mock.return_value = "2*x"
c = Calc()
first = "x**2"
second = 1
expected_result = "2*x"
self.assertEqual(expected_result, c.derivative(first, second))
class TestCalc:
add_int_data = getData('add', 'int')
add_float_data = getData('add', 'float')
div_int_data = getData('div', 'int')
div_float_data = getData('div', 'float')
div_zero_data = getData('div', 'zero')
def setup(self):
print('开始计算')
self.calc = Calc()
def teardown(self):
print('计算结束')
@pytest.mark.parametrize("a,b,result", add_int_data[0], ids=add_int_data[1])
def test_add(self, a, b, result):
assert result == self.calc.add(a, b)
@pytest.mark.parametrize("a,b,result", add_float_data[0], ids=add_float_data[1])
def test_add_float(self, a, b, result):
assert result == round(self.calc.add(a, b), 10)
@pytest.mark.parametrize("a,b,result", div_int_data[0], ids=div_int_data[1])
def test_div(self, a, b, result):
assert result == self.calc.div(a, b)
@pytest.mark.parametrize("a,b,result", div_zero_data[0], ids=div_zero_data[1])
def test_div_zero(self, a, b, result):
with pytest.raises(ZeroDivisionError):
assert result == self.calc.div(a, b)
@pytest.mark.parametrize("a,b,result", div_float_data[0], ids=div_float_data[1])
def test_div_float(self, a, b, result):
assert result == round(self.calc.div(a, b), 10)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calc = Calc()
def test_instantiate_calc(self):
self.assertIsInstance(self.calc, Calc)
def test_results_property_calc(self):
self.assertEqual(self.calc.result, 0)
def test_add_method_calc(self):
self.assertEqual(self.calc.add(2, 2), 4)
self.assertEqual(self.calc.result, 4)
def test_subtract_method_calc(self):
self.assertEqual(self.calc.subtract(2, 2), 0)
self.assertEqual(self.calc.result, 0)
def test_mul_method_calc(self):
self.assertEqual(self.calc.mul(2, 2), 4)
self.assertEqual(self.calc.result, 4)
def test_div_method_calc(self):
self.assertEqual(self.calc.div(2, 2), 1)
self.assertEqual(self.calc.result, 1)
def test_sq_method_calc(self):
self.assertEqual(self.calc.sq(2), 4)
self.assertEqual(self.calc.result, 4)
class TestCalc(unittest.TestCase):
'''计算器模块3'''
def setUp(self):
print("测试开始")
self.cal = Calc() # 在这里实例化
def test_add(self):
'''计算器加法模块3'''
self.assertEqual(self.cal.add(1, 2), 3, 'test add1 failed')
self.assertNotEquals(self.cal.add(1, 4), 4, 'test add2 failed')
print("test_add pass")
# @unittest.skip("暂时不测")
def test_minus(self):
'''计算器减法模块3'''
self.assertEqual(self.cal.minus(1, 2), -1, 'test minus1 failed')
self.assertEqual(self.cal.minus(3, 2), 1, 'test minus2 failed')
print("test_minus pass")
def test_divide(self):
"""计算器除法法模块3"""
self.assertEqual(self.cal.divide(6, 2), 3, 'test divide1 failed')
self.assertEqual(self.cal.divide(3, 2), 1.5, 'test divide2 failed')
def test_multiple(self):
"""计算器乘法模块3"""
self.assertEqual(self.cal.multiple(6, 2), 13, 'test multiple1 failed')
self.assertEqual(self.cal.multiple(3, 2), 6, 'test multiple2 failed')
def tearDown(self):
print("测试结束")
def do_dhroll(self,rest):
try:
z=rest.split(" ")
#why are we using z.pop below? to standardize the output of course!
#if the second number is a number, it's probably input like ,dhroll (dice) (tn)
if re.match("\d+",z[1]):
# this is the target number , for stuff like 1d100 80 and such.
TN=int(z.pop(1))
# and the one before it is the dice roll
total=Calc(z.pop(0))
# if it ain't, then maybe it was assumed dice=1d100 and given as ,dhroll (tn)
elif re.match("\d+",z[0]):
#cause of format, tn will be first argument
TN=int(z.pop(0))
#default diceroll
total=Calc("1d100")
else :
#f**k you , no dice and no tn what am I supposed to do.
raise StandardError
#if there's only one thing more, it's either the skill or additives. Functions that take additives as args
# are supposed to ignore anything they don't recognize, not break on it so we're safe.
if z[-1]=z[0]:
additives=z[:]
#otherwise we've got both
elif z[-1]=z[2]:
test=z[0]
additives=z[1:]
class TestReduce(unittest.TestCase):
calc = None
def setUp(self) -> None: # 在所有测试方法之前运行
self.calc = Calc()
def test_reduce1(self):
# 1.准备测试数据
a = 6
b = 7
s = -1 # 期望结果
# 调用被测方法
sum = self.calc.reduce(a, b) # sum 是实际结果
# 断言
self.assertEqual(s, sum)
def test_reduce2(self):
# 1.准备测试数据
a = -6
b = -7
s = 1 # 期望结果
# 调用被测方法
sum = self.calc.reduce(a, b) # sum 是实际结果
# 断言
self.assertEqual(s, sum)
def test_reduce3(self):
# 1.准备测试数据
a = 9
b = -7
s = 16 # 期望结果
# 调用被测方法
sum = self.calc.reduce(a, b) # sum 是实际结果
# 断言
self.assertEqual(s, sum)
def test_reduce4(self):
# 1.准备测试数据
a = -9
b = 8
s = -17 # 期望结果
# 调用被测方法
sum = self.calc.reduce(a, b) # sum 是实际结果
# 断言
self.assertEqual(s, sum)
def test_Add4(self):
# 1.准备测试数据
a = -6
b = 6999999999999999999999999999999999999999999999999999999999999
s = 6999999999999999999999999999999999999999999999999999999999993 # 期望结果
# 调用被测方法
calc = Calc()
sum = calc.add(a, b) # sum 是实际结果
# 断言
self.assertEqual(s, sum)
def test_Add1(self):
#1.准备测试数据
x = 5
y = 8
s = 13 #期望结果
#调用测试方法
calc = Calc()
sum = calc.add(x, y)
#断言
self.assertEqual(s, sum)
def test_Add1(self):
# 1.准备测试数据
a = 6
b = 7
s = 13 # 期望结果
# 调用被测方法
calc = Calc()
sum = calc.add(a, b) # sum 是实际结果
# 断言
self.assertEqual(s, sum)
class MinhaClasseDeTestes(TestCase):
def setUp(self):
self.c = Calc()
def test_soma_deve_retornar_2_com_entrada_de_1_1(self):
self.assertEqual(self.c.soma(1, 1), 2, 'Deu ruim a soma')
def test_sub_deve_retornar_0_com_entrada_de_1_1(self):
self.assertEqual(self.c.sub(1, 1), 0, 'Deu ruim a sub')
def test_mult_deve_retornar_6_com_entrada_de_2_3(self):
self.assertEqual(self.c.mult(2, 3), 6, 'Deu ruim a mult')
def test_div_deve_retornar_0_com_entrada_de_2_2(self):
self.assertEqual(self.c.div(2, 2), 0, 'Deu ruim a div')
class TestFun(unittest.TestCase):
def setUp(self):
self.obj = Calc()
print 'start'
def test_add(self):
self.assertEqual(self.obj.add(1, 2, 3), 6)
def test_sub(self):
self.assertEqual(self.obj.sub(1, 2, 3), -4)
def test_mul(self):
self.assertEqual(Calc.mul(1, 2, 3), 6)
def test_div(self):
self.assertEqual(self.obj.div(4, 2, 1), 6)
def tearDown(self):
print 'done'
def main(): # 전역함수
calc = Calc(int(input("첫번째 수")), int(input("두번째 수")))
# 생성자. input은 숫자를 넣어도 문자로 인식하기 때문에 int를 줘야
print(calc.first)
print(calc.second)
print("{}+{}={}".format(calc.first, calc.second, calc.sum()))
print("{}-{}={}".format(calc.first, calc.second, calc.sub()))
print("{}*{}={}".format(calc.first, calc.second, calc.mul()))
print("{}/{}={}".format(calc.first, calc.second, calc.div()))
def Calc(self):
symbols = ["PLUS", "MINUS", "TIMES", "DIVIDE"]
o1 = self.advance()
if (self.peek().type in symbols):
operands = []
operators = []
operands.append(o1)
while (self.peek().type in symbols):
operator = self.advance()
o2 = self.advance()
operands.append(o2)
operators.append(operator)
return Calc(operands=operands, operators=operators)
else:
return Term(type=o1.type, term=o1.value)
from Calc import Calc
import script
def main(c):
op=int(input("Digite 1 para somar:\nDigite 2 para subtrair:\nDigite 3 para multiplique:\nDigite 4 para dividir:\n"))
if op==1:
print(c.some())
elif op==2:
print(c.subtraia())
elif op==3:
print(c.multiplique())
elif op==4:
print(c.divida())
else:
print("Erro")
return -1
if __name__=="__main__":
script.say_hi("Mundo!")
print("Calculadora utilizando Lua e python")
a=float(input("Digite 1 número:"))
b=float(input("Digite 1 número:"))
c=Calc(a,b)
main(c)
def setUp(self):
print("测试开始")
self.cal = Calc() # 在这里实例化
def test_add():
x,y = 1,2
instance = Calc(x,y)
if instance.add() == x+y:
print('True')
w = (b - a) / N
X = [a + w * i for i in range(N + 1)]
Y = [f(x) for x in X]
self.ax.plot(X, Y)
plt.show(block=False)
def clearPlot(self):
self.ax.cla()
plt.show(block=False)
def plotf(self, a, b, N=100):
f = self.c.f
self.newPlot(f, a, b, N)
def plotfp(self, a, b, N=100):
f = self.c.fp
self.newPlot(f, a, b, N)
def plotInt(self, a, b, N=100):
def f(x):
return self.c.trap(0, x, N)
self.newPlot(f, a, b, N)
if __name__ == '__main__':
c = Calc(lambda x: x**2)
p = FunctionPlots(c)
p.plotf(-2, 2, 100)
p.plotfp(-2, 2, 100)
p.plotInt(-2, 2)
def test_div_except(self):
self.cal = Calc(4, 0)
self.assertRaises(TypeError)
def test_checking_log_of_string_raises_exception(self):
calcul = Calc()
a = "String"
self.assertRaises(WrongInput, calcul.log10, a)
def test_checking_log_of_float_returns_correct_value(self):
calcul = Calc()
a = 100.0
log = 2
self.assertAlmostEqual(calcul.log10(a), 2)
def test_checking_division_of_two_strings_raises_exception(self):
calcul = Calc()
a = "string1"
b = "string2"
self.assertRaises(NotANumber, calcul.divide, a, b)
def test_checking_division_of_two_floats_returns_correct_value(self):
calcul = Calc()
a = 2.0
b = 4.0
result = 0.5
self.assertAlmostEqual(calcul.divide(a, b), result)
# -*- coding: utf-8 -*- from Calc import Calc calc = Calc() calc.start()
def setUpClass(cls):
print u"单元测试前，创建Calc的实例"
cls.c = Calc()
def test_checking_derivative_of_string_fcn_returns_correct_value(self):
calcul = Calc()
def setUp(self):
self.cal = Calc(4, 5)
def test_checking_addition_of_floats_returns_sum(self):
calcul = Calc()
a = 7.0
b = 1.0
suma = 8.0
self.assertAlmostEqual(calcul.add(a, b), suma)
def test_checking_log_of_value_smaller_than_one_raises_exception(self):
calcul = Calc()
a = 0.5
self.assertRaises(LowerThanOne, calcul.log10, a)
def test_checking_derivative_of_number_raises_exception(self):
calcul = Calc()
a = 7
self.assertRaises(NotAString, calcul.derivate, a)