def test_sum(self):
expected = 4
a = 2
b = 2
calc = Calculator()
result = calc.sum(a, b)
self.assertEqual(result, expected, 'it\'s wrong')
def test_calculator_1(self):
cal = Calculator()
out = StringIO()
with patch("sys.stdout", out) as fakeOutput:
cal.calculate()
output = fakeOutput.getvalue().strip()
self.assertEqual(output, "81")
def test_calculator_2(self):
cal = Calculator()
out = StringIO()
with patch("sys.stdout", out) as fakeOutput:
cal.calculate()
output = fakeOutput.getvalue().strip()
self.assertEqual(output, "n and p should be non-negative")
def when_i_compute_its_operation(step):
c=Calculator()
if(world.escenario==0):
world.number = c.suma(world.number,world.numero2)
elif(world.escenario==1):
world.number = c.resta(world.number,world.numero2)
elif(world.escenario==2):
world.number = c.multi(world.number,world.numero2)
else:
world.number = c.division(world.number,world.numero2)
class TestCalculator5(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test factorial function
#
def test_calculator_factorial_method_returns_correct_result(self):
self.assertEqual(120, self.calc.factorial1(5))
self.assertEqual(1, self.calc.factorial1(0))
def test_calculator_factorial_method_returns_error_result(self):
self.assertEqual(4, self.calc.factorial1(4))
def test_calculator_factorial_method_returns_nunnumer_error_result(self):
self.assertEqual(120, self.calc.factorial1("five"))
class TestCalculator6(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test sqrRoot function
#
def test_calculator_sqrRoot_method_returns_correct_result(self):
self.assertEqual(3, self.calc.sqrroot1(9))
self.assertEqual(5, self.calc.sqrroot1(25))
self.assertEqual(0, self.calc.sqrroot1(0))
def test_calculator_sqrRoot_method_returns_error_result(self):
self.assertEqual(-3, self.calc.sqrroot1(-9))
def test_calculator_sqrRoot_method_returns_nunnumer_error_result(self):
self.assertEqual(3, self.calc.sqrroot1("nine"))
class TestCalculator4(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test divide function
#
def test_calculator_divide_method_returns_correct_result(self):
self.assertEqual(1, self.calc.divide1(2, 2))
self.assertEqual(-5, self.calc.divide1(-25, 5))
self.assertEqual(3, self.calc.divide1(9,3))
def test_calculator_divide_method_returns_error_result(self):
self.assertEqual(5, self.calc.divide1(2, 0))
def test_calculator_divide_method_returns_nunnumer_error_result(self):
self.assertEqual(3, self.calc.divide1("six", 2))
class TestCalculator1(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test add function
#
def test_calculator_add_method_returns_correct_result(self):
self.assertEqual(4, self.calc.add1(2, 2))
self.assertEqual(0, self.calc.add1(-5, 5))
self.assertEqual(-8, self.calc.add1(-4,-4))
def test_calculator_add_method_returns_error_result(self):
self.assertEqual(5, self.calc.add1(2, 2))
def test_calculator_add_method_returns_nunnumer_error_result(self):
self.assertEqual(4, self.calc.add1("two", 2))
class TestCalculator3(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test multiply function
#
def test_calculator_multiply_method_returns_correct_result(self):
self.assertEqual(4, self.calc.multiply1(2, 2))
self.assertEqual(-25, self.calc.multiply1(-5, 5))
self.assertEqual(9, self.calc.multiply1(3,3))
def test_calculator_multiply_method_returns_error_result(self):
self.assertEqual(5, self.calc.multiply1(2, 2))
def test_calculator_multiply_method_returns_nunnumer_error_result(self):
self.assertEqual(10, self.calc.multiply1("five", 2))
class TestCalculator2(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test subtract function
#
def test_calculator_subtract_method_returns_correct_result(self):
self.assertEqual(0, self.calc.subtract1(2, 2))
self.assertEqual(-10, self.calc.subtract1(-5, 5))
self.assertEqual(10, self.calc.subtract1(5,-5))
def test_calculator_subtract_method_returns_error_result(self):
self.assertEqual(5, self.calc.subtract1(2, 2))
def test_calculator_subtract_method_returns_nunnumer_error_result(self):
self.assertEqual(3, self.calc.subtract1("five", 2))
class TestCalculator9(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test floor function
#
def test_calculator_floor_method_returns_correct_result(self):
self.assertEqual(343, self.calc.floor1(343.93))
self.assertEqual(22, self.calc.floor1(22.33))
self.assertEqual(-14, self.calc.floor1(-13.33))
def test_calculator_floor_method_returns_error_result(self):
self.assertEqual(23, self.calc.floor1(22.22))
def test_calculator_floor_method_returns_nunnumer_error_result(self):
self.assertEqual(3, self.calc.floor1("three.three"))
class TestCalculator8(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test power function
#
def test_calculator_power_method_returns_correct_result(self):
self.assertEqual(27, self.calc.power1(3,3))
self.assertEqual(.125, self.calc.power1(8,-1))
self.assertEqual(-3, self.calc.power1(-3,1))
def test_calculator_power_method_returns_error_result(self):
self.assertEqual(-9, self.calc.power1(-3,-3))
def test_calculator_power_method_returns_nunnumer_error_result(self):
self.assertEqual(9, self.calc.power1("three",3))
class TestCalculator7(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
# test square function
#
def test_calculator_square_method_returns_correct_result(self):
self.assertEqual(9, self.calc.square1(3))
self.assertEqual(1, self.calc.square1(1))
self.assertEqual(9, self.calc.square1(-3))
def test_calculator_square_method_returns_error_result(self):
self.assertEqual(-9, self.calc.square1(-3))
def test_calculator_square_method_returns_nunnumer_error_result(self):
self.assertEqual(9, self.calc.square1("three"))
class TddInPythonExample(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_calculator_add_method_returns_correct_result(self): calc = Calculator() result = self.calc.add(2,2) self.assertEqual(4, result)
def main(argv=None):
people = [
Person("Person 1",500),
Person("Person 2",1000),
Person("Person 3",1500),
]
calc = Calculator()
calc.people = people
calc.charge = 42.95
calc.calculate()
print "Total income including all parties: ${0:03.2f}".format(calc.total_income)
for p in calc.people:
print "Amount due by {0} whose income is ${1:03.2f} is ${2:03.2f}.".format(p.name,p.income,p.due)
print "Each party is paying ${0:03.2f}% of their income.".format(calc.due_percent)
def __init__(self, master = None):
# call the frame constructor
Frame.__init__(self, master)
# give the calculator a 10 pixel border all around
self.grid(padx=10, pady=10)
# try Bitsteam Vera font first cause its a cool (and open-source)
if "Bitstream Vera Sans Mono" in tkFont.families():
self.font = tkFont.Font(family="Bitstream Vera Sans Mono", size="14")
else:
self.font = tkFont.Font(family="Courier", size="14")
# populate the widgets
self.__populate()
# Call Calculator class constructor
Calculator.__init__(self, display = self.display)
# the functions of the calculator
self.functions = {
"add":[CFunctions.add, "+", 2, self.TYPE_OPERATOR],
"subtract":[CFunctions.subtract, "-", 2, self.TYPE_OPERATOR],
"multiply":[CFunctions.multiply, "*", 2, self.TYPE_OPERATOR],
"divide":[CFunctions.divide, u"\u00F7", 2, self.TYPE_OPERATOR],
"tan":[math.tan, "Tan", 1, self.TYPE_FUNCTION],
"sin":[math.sin, "Sin", 1, self.TYPE_FUNCTION],
"cos":[math.cos, "Cos", 1, self.TYPE_FUNCTION],
"atan":[math.tan, "aTan", 1, self.TYPE_FUNCTION],
"asin":[math.sin, "aSin", 1, self.TYPE_FUNCTION],
"acos":[math.cos, "aCos", 1, self.TYPE_FUNCTION],
"todegree":[math.degrees, ">Deg", 1, self.TYPE_FUNCTION],
"toradian":[math.radians, ">Rad", 1, self.TYPE_FUNCTION],
"pow":[CFunctions.pow, "^", 2, self.TYPE_OPERATOR],
"mod":[CFunctions.fmod, "%", 2, self.TYPE_OPERATOR],
"factorial":[CFunctions.factorial, "Factorial", 1, self.TYPE_FUNCTION],
"log":[CFunctions.log, "log", 2, self.TYPE_FUNCTION],
"ln":[math.log, "ln", 1, self.TYPE_FUNCTION],
"sqrt":[decimal.Decimal.sqrt, u"\u221A", 1, self.TYPE_FUNCTION],
"exp":[math.exp, "e^", 1, self.TYPE_FUNCTION],
}
# set the binds (virtual and keys)
self.__setBinds()
def run(self):
start = time.time()
self.myprint(QCoreApplication.translate('code', "Calculation Started."))
while not self.qi.empty():
(o0, d0, timetable, cat_db, direction, dist, ox, oy, dx, dy, start_time) = self.qi.get()
calc = None
from Calculator import Calculator
calc = Calculator(self,timetable,cat_db)
# 検索ごとに前回の検索内容を消去
# 検索方法を設定 1:出発時刻指定 2:到着時刻指定
calc.initialize(direction)
# 出発点（駅番号：－１）と目的地（－２）をセット
# 入力された緯度、経度から一定距離内にある駅を抽出する
dist = 300
st = int(start_time*3600*24)
h=st/3600
m=st/60%60
s=st%60
buf = u"%s, %s, %02d:%02d:%02d, %f, %d, " % (o0, d0, h,m,s, start_time, direction)
found_o, found_d = False, False
for p,d in cat_db.get_cat(ox, oy, dist).items():
calc.add_cost(-1, p, d/83*0.000694444)
calc.add_cost(p, -1, d/83*0.000694444)
found_o = True
for p,d in cat_db.get_cat(dx, dy, dist).items():
calc.add_cost(p, -2, d/83*0.000694444)
calc.add_cost(-2, p, d/83*0.000694444)
found_d = True
if not found_o or not found_d:
buf = buf + u"最寄りの交通機関が見つかりませんでした。"
else:
# 検索を実行する。
# 引数は出発時刻、到着時刻のexcel時刻シリアル値
buf = buf + calc.run( start_time )
#calc.run( start_time )
self.myprint(buf)
elapsed_time = time.time() - start
self.myprint ('elapsed time:' + "{0}".format(elapsed_time) + "[sec]")
self.myprint(QCoreApplication.translate('code', "Calculation Finished.")+u"\n")
def __init__(self):
"""
Initiate the classes used in the web page.
:return:
"""
self.wikipageviews = WikiPageViews()
self.boxofficemojo = BoxOfficeMojo()
self.wikifunctions = WikiSimpleAPIFunctions()
self.youtube = YouTube('AIzaSyDQ6enre5eE7f_BIegK-2MOBbBAlMWaJgI')
self.classifier = Classifier()
self.calculator = Calculator()
def __switch_page_cb(self,assistant,page):
if page == self.asnt_p1:
pass
elif page == self.asnt_p2:
pass
elif page == self.asnt_p3:
charge = float(self.bill_entry.get_text())
calc_people = []
for person in self.people:
calc_people.append(Person(person[0],person[1]))
calc = Calculator()
calc.people = calc_people
calc.charge = charge
calc.calculate()
str = ""
str+= "Total income including all parties: ${0:03.2f}\n\n".format(calc.total_income)
for p in calc.people:
str+= "Amount due by {0} whose income is ${1:03.2f} is ${2:03.2f}.\n".format(p.name,p.income,p.due)
str+= "\nEach party is paying {0:03.2f}% of their income.".format(calc.due_percent)
buf = self.res_tv.get_buffer()
buf.set_text(str)
print "__change_page_cb",page
class CalculatorLibrary(object):
def __init__(self):
self._calc = Calculator()
self._result = ''
def push_button(self, button):
self._result = self._calc.push(button)
def result_should_be(self, expected):
assert self._result == expected, '%s != %s' % (self._result, expected)
def input(self, expression):
for button in expression.replace(' ',''):
self.push_button(button)
def should_fail(self, expression):
try:
self.input(expression)
except CalculationError, err:
return str(err)
else:
def test_division_12_entre_6(self): self.cal=Calculator() self.assertEqual(2, self.cal.division(12,6))
def test_suma_2_mas_2(self): self.cal=Calculator() self.assertEqual(4, self.cal.suma(2,2))
class MyTestCase(unittest.TestCase):
calculator = None
@classmethod
def setUpClass(cls):
print('')
print('setUpClass')
@classmethod
def tearDownClass(cls):
print('')
print('tearDownClass')
def setUp(self):
self.calculator = Calculator()
print('')
print('setUp')
def tearDown(self):
if self.calculator is not None:
self.calculator = None
print('')
print('tearDown')
def test_plus(self):
test_data_row_list = list()
with open('./src//plus_test.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
test_data_row_list.append(row)
# print(','.join(row))
print('')
print('******test_plus******')
# print(','.join(row))
for row in test_data_row_list:
x = row[0]
y = row[1]
expect_result = row[2]
result = self.calculator.plus(x, y)
print(
str(x) + ' + ' + str(y) + ' = ' + str(result) + ', expect ' +
str(expect_result))
self.assertEqual(int(result), int(expect_result))
def test_minus(self):
test_data_row_list = list()
with open('./src//minus_test.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
test_data_row_list.append(row)
# print(','.join(row))
print('')
print('******test_minus******')
# print(','.join(row))
for row in test_data_row_list:
x = row[1]
y = row[0]
expect_result = row[2]
result = self.calculator.minus(x, y)
print(
str(x) + ' - ' + str(y) + ' = ' + str(result) + ', expect ' +
str(expect_result))
self.assertEqual(int(result), int(expect_result))
def test_multiply(self):
test_data_row_list = list()
with open('./src//multiply_test.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
test_data_row_list.append(row)
# print(','.join(row))
print('')
print('******test_multiply******')
# print(','.join(row))
for row in test_data_row_list:
x = row[0]
y = row[1]
expect_result = row[2]
result = self.calculator.multiply(x, y)
print(
str(x) + ' * ' + str(y) + ' = ' + str(result) + ', expect ' +
str(expect_result))
self.assertEqual(int(result), int(expect_result))
def test_divide(self):
test_data_row_list = list()
with open('./src//divide_test.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
test_data_row_list.append(row)
# print(','.join(row))
print('')
print('******test_divide******')
# print(','.join(row))
for row in test_data_row_list:
x = row[1]
y = row[0]
expect_result = row[2]
result = self.calculator.divide(x, y)
print(
str(x) + ' / ' + str(y) + ' = ' + str(result) + ', expect ' +
str(expect_result))
self.assertEqual(round(float(result), 9), float(expect_result))
def test_squared(self):
test_data_row_list = list()
with open('./src//squared_test.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
test_data_row_list.append(row)
# print(','.join(row))
print('')
print('******test_squared******')
# print(','.join(row))
for row in test_data_row_list:
x = row[0]
expect_result = row[1]
result = self.calculator.squared(x)
print(
str(x) + ' ** ' + ' = ' + str(result) + ', expect ' +
str(expect_result))
self.assertEqual(int(result), int(expect_result))
def test_sqrt(self):
test_data_row_list = list()
with open('./src//sqrt_test.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
test_data_row_list.append(row)
# print(','.join(row))
print('')
print('******test_sqrt******')
# print(','.join(row))
for row in test_data_row_list:
x = row[0]
expect_result = row[1]
result = self.calculator.sqrt(x)
print(
str(x) + ' ** (1 / 2)' + ' = ' + str(result) + ', expect ' +
str(expect_result))
self.assertEqual(round(float(result), 8),
round(float(expect_result), 8))
print "options : print options"
print "quit : exit\n"
def calc_exp(exp, c):
# Compile exps before evaluation
exps = Compiler.compile(exp)
# Evaluate each compiled expression
for exp in exps:
c.calc(exp)
if __name__ == '__main__':
# Create a calculator
c = Calculator()
print "Welcome to the coolest calculator CLI!"
# Print options
print_options()
# While not quit
while True:
exp = raw_input("insert a series : ")
if exp == "status":
c.get_status()
continue
if exp == "options":
print_options()
def setUp(self) -> None:
self.calculator = Calculator()
"Enter the directory in which you would like to copy file. \n For example C:\Users\achock\PythonDev\n"
)
ndir = os.path.isdir(destPath)
file.verDir(ndir)
file.moveFile(fname, destPath, opsys)
elif choice == 2:
print "Your options are:"
print " "
print "1) Addition"
print "2) Subtraction"
print "3) Multiplication"
print "4) Division"
print "5) Quit calculator"
print " "
operator = int(raw_input("Choose your option: ").strip())
calc = Calculator()
if operator == 1:
add1 = input("Add this: ")
add2 = input("to this: ")
print add1, "+", add2, "=", calc.add(add1, add2)
elif operator == 2:
sub2 = input("Subtract this: ")
sub1 = input("from this: ")
print sub1, "-", sub2, "=", calc.sub(sub1, sub2)
elif operator == 3:
mul1 = input("Multiply this: ")
mul2 = input("with this: ")
print mul1, "*", mul2, "=", calc.multiply(mul1, mul2)
elif operator == 4:
div1 = input("Divide this: ")
div2 = input("by this: ")
def setup(self):
print("开始计算")
self.cal = Calculator()
def test_instantiate_calculator(self):
calculator = Calculator()
self.assertIsInstance(calculator, Calculator)
def test_squarert_method_calculator(self):
calculator = Calculator()
self.assertEqual(calculator.squareroot(16), 4)
self.assertEqual(calculator.result, 4)
def test_square_method_calculator(self):
calculator = Calculator()
self.assertEqual(calculator.square(2, 2), 4)
self.assertEqual(calculator.result, 4)
def test_divide_method_calculator(self):
calculator = Calculator()
self.assertEqual(calculator.divide(2, 2), 1)
self.assertEqual(calculator.result, 0)
def test_multiply_method_calculator(self):
calculator = Calculator()
self.assertEqual(calculator.multiply(2, 2), 4)
self.assertEqual(calculator.result, 4)
def test_subtract_method_calculator(self):
calculator = Calculator()
self.assertEqual(calculator.subtract(2, 2), 0)
self.assertEqual(calculator.result, 0)
def runTest(self):
calc = Calculator()
self.assertEqual(calc.calc("6+9"), 15, 'wrong simple addition')
self.assertEqual(calc.calc("6*9"), 54, 'wrong simple multiplication')
self.assertEqual(calc.calc("(6*9)/2"), 27, 'wrong simple division')
self.assertEqual(calc.calc("(6*9)/2 - 10"), 17)
print "Program execution started..."
''' Validate the configuration for the program'''
validator = Validator()
if validator.validateConfig() == False:
exit(1)
''' Read input directory and create data file '''
inputReader = InputReader()
inputReader.readPortfolioFile()
for portfolio in Data.portfolios:
logging.debug("Started Processing Portfolio"+ portfolio.name)
Config.inputFileDirectory = portfolio.inputDirectory
inputReader.readData()
''' Calculate W for the portfolio '''
calculator = Calculator()
totalWForPortfolio = calculator.calculateWForPortfolio(0)
portfolio.setTotalW(totalWForPortfolio)
outputWriter = OutputWriter()
portfolioOutputDirectory = Config.outputFileDirectory + "/" + portfolio.name
if not os.path.exists(portfolioOutputDirectory):
os.mkdir(portfolioOutputDirectory)
if os.path.isdir(portfolioOutputDirectory):
outputWriter.writeData(portfolioOutputDirectory)
print "Creating required output files..."
outputWriter.writeSummary()
print "Program execution completed successfully."
import unittest
from Calculator import Calculator
from CsvReader import CsvReader
from pprint import pprint
calculator = Calculator()
class MyTestCase(unittest.TestCase):
def test_add_calculator(self):
test_input = CsvReader('/src/Addition.csv').data
for row in test_input:
self.assertEqual(calculator.add(row['Value 1'], row['Value 2']),
int(row['Result']))
def test_sub_calculator(self):
test_input = CsvReader('/src/Subtraction.csv').data
for row in test_input:
self.assertEqual(calculator.sub(row['Value 1'], row['Value 2']),
int(row['Result']))
def test_mul_calculator(self):
test_input = CsvReader('/src/Multiplication.csv').data
for row in test_input:
self.assertEqual(calculator.mul(row['Value 1'], row['Value 2']),
int(row['Result']))
def test_div_calculator(self):
test_input = CsvReader('/src/Division.csv').data
for row in test_input:
self.assertEqual(calculator.div(row['Value 1'], row['Value 2']),
float(row['Result']))
def test_suma_2_mas_2(self): cal = Calculator(2,2) self.assertEqual(4, cal.sumar())
def calc(self):
self.calc = Calculator()
def test_add_method_calculator(self):
calculator = Calculator()
self.assertEqual(calculator.add(2, 2), 4)
self.assertEqual(calculator.result, 4)
def test_calc_add(self):
c = Calculator()
assert c.add(3, 3) == 6
def test_suma_2_mas_2(self):
'''self se refiere al mismo objeto/por convencion
todos los metodos deben llevar test'''
cal = Calculator()
self.assertEqual(4, cal.summa(2, 2))
from Fraction import Fraction
from Calculator import Calculator
import main
##small cases
#case 1
frac1 = Fraction("1/2")
frac2 = Fraction("3_3/4")
result = Calculator(frac1, frac2).multiplication()
print(result.convert_to_string())
#case 2
frac1 = Fraction("2_2/3")
frac2 = Fraction("4")
result = Calculator(frac1, frac2).addition()
print(result.convert_to_string())
#case 3
frac1 = Fraction("4")
frac2 = Fraction("2/3")
result = Calculator(frac1, frac2).subtraction()
print(result.convert_to_string())
#case 4
frac1 = Fraction("2/3")
def test_calcular_1_igual(self):
calc=Calculator()
calc.input_number('1')
calc.input_number('=')
self.assertEqual(calc.display(),'1')
def test_calc_multiply(self):
c = Calculator()
assert c.multiply(2, 5) == 10
def setUp(self):
self.calculator = Calculator()
print('')
print('setUp')
def test_calc_divide(self):
c = Calculator()
assert c.divide(20, 5) == 4
def test_division_2_entre_2(self): self.cal=Calculator() self.assertEqual(1, self.cal.division(2,2))
def test_calc_square(self):
c = Calculator()
assert c.square(10) == 100
def test_suma_1_mas_4(self): self.cal=Calculator() self.assertEqual(5, self.cal.suma(1,4))
def test_calc_squareroot(self):
c = Calculator()
assert c.squareroot(9) == 3
from Calculator import Calculator
if __name__ == "__main__":
calc = Calculator()
result = calc.calculate("10/4*2*3-15")
print(result)
def test_calc(self):
c = Calculator()
assert c
class TestCalculate:
# 执行类 前后分别执行setup_class teardown_class
def setup_class(self):
print("执行在类前")
def teardown_class(self):
print("执行在类后")
#执行测试用例之前执行
def setup(self):
print("开始计算")
self.cal = Calculator()
#测试加法
#@pytest.mark.parametrize(argnames,argvalues)
#argnames:要参数化的变量，可以String,list,tuple
#argvalues：参数化的值,list,list[tuple]
#ids输入中文，必须在同级目录中新建 conftest.py代码
@pytest.mark.parametrize(
"a,b,expect",
[(random.randint(0, 5), random.randint(0, 5), random.randint(5, 10))],
ids=["随机数加法"])
def test_add(self, a, b, expect):
sum = self.cal.add(a, b)
print(f"两数相加实际结果{sum},期望结果{expect}")
assert expect == sum
# 测试减法
# @pytest.mark.parametrize(argnames,argvalues)
# argnames:要参数化的变量，可以String,list,tuple
# argvalues：参数化的值,list,list[tuple]
@pytest.mark.parametrize(
["a", "b", "expect"],
[(random.randint(0, 5), random.randint(0, 5), random.randint(5, 10))],
ids=["随机数减法"])
def test_del(self, a, b, expect):
dele = self.cal.dele(a, b)
print(f"两数相减实际结果{dele},期望结果{expect}")
assert expect == dele
# 测试乘法
# @pytest.mark.parametrize(argnames,argvalues)
# argnames:要参数化的变量，可以String,list,tuple
# argvalues：参数化的值,list,list[tuple]
@pytest.mark.parametrize(
("a", "b", "expect"),
[(random.randint(0, 5), random.randint(0, 5), random.randint(0, 25))],
ids=["随机数乘法"])
def test_mult(self, a, b, expect):
mult = self.cal.mult(a, b)
print(f"两数相乘实际结果{mult},期望结果{expect}")
assert expect == mult
# 测试
@pytest.mark.parametrize(
"a,b,expect",
[(random.randint(0, 5), random.randint(0, 5), random.randint(5, 10))],
ids=["随机数除法"])
def test_chu(self, a, b, expect):
try:
True == (b == 0)
except:
assert "除数不能为0"
else:
div = self.cal.div(a, b)
print(f"两数相除实际结果{div},期望结果{expect}")
assert expect == div
#执行测试用例之后执行
def teardown(self):
print("结束计算")
def test_add(self):
calculator = Calculator()
self.assertEqual(calculator.add(1, 1), 2)
def setUp(self): self.calc = Calculator()
def setUp(self):
self.cal = Calculator(8, 4)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_subtraction(self):
print("________Subtraction________")
test_data = CsvReader('/src/csv/Subtraction.csv').data
for row in test_data:
self.assertEqual(
self.calculator.subtract(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
print(row['Value 2'], '-', row['Value 1'], '=',
self.calculator.result)
def test_addition(self):
print("________Addition________")
test_data = CsvReader('/src/csv/Addition.csv').data
for row in test_data:
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
print(row['Value 2'], '+', row['Value 1'], '=',
self.calculator.result)
def test_multiplication(self):
print("________Multiplication________")
test_data = CsvReader('/src/csv/Multiplication.csv').data
for row in test_data:
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
print(row['Value 2'], '*', row['Value 1'], '=',
self.calculator.result)
def test_division(self):
print("________Division________")
test_data = CsvReader('/src/csv/Division.csv').data
for row in test_data:
self.assertAlmostEqual(
self.calculator.divide(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertAlmostEqual(self.calculator.result,
float(row['Result']))
print(row['Value 2'], '/', row['Value 1'], '=',
self.calculator.result)
def test_square(self):
print("________Square________")
test_data = CsvReader('/src/csv/Square.csv').data
for row in test_data:
self.calculator.square(row['Value 1'])
self.assertEqual(self.calculator.result, int(row['Result']))
print(row['Value 1'], '^2', '=', self.calculator.result)
def test_squareroot(self):
print("________Square Root________")
test_data = CsvReader('/src/csv/Square_Root.csv').data
for row in test_data:
self.calculator.sqroot(int(row['Value 1']))
self.assertAlmostEqual(self.calculator.result,
float(row['Result']))
print('√', row['Value 1'], '=', self.calculator.result)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_subtraction(self):
test_data = CsvReader('./src/test_subtraction.csv').data
for row in test_data:
self.assertEqual(
self.calculator.subtract(int(row['Value 2']),
int(row['Value 1'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_addition(self):
test_data = CsvReader('./src/test_addition.csv').data
for row in test_data:
self.assertEqual(
self.calculator.add(int(row['Value 1']), int(row['Value 2'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_multiply(self):
test_data = CsvReader('./src/test_multiplication.csv').data
pprint(test_data)
for row in test_data:
self.assertEqual(
self.calculator.multiply(int(row['Value 1']),
int(row['Value 2'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_division(self):
test_data = CsvReader('./src/test_division.csv').data
for row in test_data:
self.assertEqual(
self.calculator.divide(int(row['Value 1']),
int(row['Value 2'])),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_square(self):
test_data = CsvReader('./src/test_square.csv').data
pprint(test_data)
for row in test_data:
self.assertEqual(self.calculator.squaring(int(row['Value 1'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_square_root(self):
test_data = CsvReader('./src/test_square_root.csv').data
pprint(test_data)
for row in test_data:
self.assertAlmostEqual(self.calculator.sqrt(int(row['Value 1'])),
float(row['Result']),
places=4)
self.assertAlmostEqual(self.calculator.result,
float(row['Result']),
places=4)
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
def test_calc_subtract(self):
c = Calculator()
assert c.subtract(20, 10) == 10
def test_results_property_calculator(self):
calculator = Calculator()
self.assertEqual(calculator.result, 0)
