class TestCalculator:
@pytest.fixture
def calc(self):
self.calc = Calculator()
def test_should_return_zero_when_got_empty_string(self, calc):
result = self.calc.add("")
assert_that(result).is_equal_to(0)
def test_should_return_number_when_given_number(self, calc):
result = self.calc.add("1")
assert_that(result).is_equal_to(1)
def test_should_add_two_numbers_separated_with_comma(self, calc):
result = self.calc.add("1,2")
assert_that(result).is_equal_to(3)
def test_should_add_more_numbers_separated_with_comma(self, calc):
result = self.calc.add("1,2, 3, 4 , 5, 6,7,8,9,10")
assert_that(result).is_equal_to(55)
def test_should_add_three_numbers_separated_with_comma_or_new_line(
self, calc):
result = self.calc.add("1,2\n4")
assert_that(result).is_equal_to(7)
def test_should_raise_exception_when_negative_number_provided(self, calc):
assert_that(self.calc.add).raises(
NegativeNumberException).when_called_with("-1")
def test_should_include_all_negative_numbers_in_exception_message(
self, calc):
assert_that(self.calc.add).raises(NegativeNumberException).when_called_with("-1,-2") \
.is_equal_to("Negatives: -1 -2")
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property_calculator(self):
self.assertEqual(self.calculator.result, 6)
def test_addition_method_calculator(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Addition.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
def test_subtract_method_calculator(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Subtraction.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
class TestCal:
def setup_class(self):
print("开始计算")
self.calc = Calculator()
def teardown_class(self):
print("计算结束")
@pytest.mark.parametrize('a,b,expect',
get_datas()['int_datas'],
ids=get_datas()['ids'])
def test_add_int(self, a, b, expect):
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize('a,b,expect', [
[0.1, 0.1, 0.2],
[0.1, 0.2, 0.3],
],
ids=['float1', 'float2'])
def test_add_int_float(self, a, b, expect):
assert expect == round(self.calc.add(a, b), 2)
@pytest.mark.parametrize('a,b,expect', [[0.1, 0, False], [2, 2, 2]])
def test_div(self, a, b, expect):
try:
assert expect == self.calc.div(a, b)
except ZeroDivisionError:
print("除数为0")
class TestCal:
def setup_class(self):
print("setup")
self.calc = Calculator()
def teardown_class(self):
print("teardown")
@pytest.mark.parametrize(
'a,b,expect',
[[1, 1, 2], [0.1, 0.1, 0.2], [1000, 1000, 2000], [0, 1000, 1000]],
ids=['int1', 'float', 'bignum', 'zeronum'])
def test_add(self, a, b, expect):
assert expect == self.calc.add(a, b)
def test_add1(self):
# calc = Calculator()
assert 0.2 == self.calc.add(0.1, 0.1)
def test_add2(self):
# calc = Calculator()
assert 2000 == self.calc.add(1000, 1000)
def test_add2(self):
# calc = Calculator()
assert 1000 == self.calc.add(0, 1000)
def test_failing_log_calls_service():
#logger = Mock(write=Exception("IO error"))
logger = ThrowingLogger()
service = Mock()
calcer = Calculator(logger, service)
calcer.add("1,2,3")
assert service.error.called
class TestCal:
def setup_class(self):
print("setup")
self.calc = Calculator()
def teardown_class(self):
print("teardown")
@pytest.mark.parametrize('a,b,expect',
get_datas()['add'],
ids=get_datas()['ids'])
def test_add_int(self, a, b, expect):
assert expect == self.calc.add(a, b)
@pytest.mark.parametrize('a,b,expect', [[0.1, 0.1, 0.2], [0.4, 0.8, 1.2]],
ids=['float22', 'float222'])
def test_add_float(self, a, b, expect):
assert expect == round(self.calc.add(a, b), 2)
@pytest.mark.parametrize('a,b,expect', [[1, 1, 0], [20, 10, 10]],
ids=['int1', 'int_1'])
def test_less_int(self, a, b, expect):
assert expect == self.calc.less(a, b)
@pytest.mark.parametrize('a,b,expect', [[0.5, 0.1, 0.4], [1.8, 0.8, 1]],
ids=['float1', 'float_1'])
def test_less_float(self, a, b, expect):
assert expect == self.calc.less(a, b)
@pytest.mark.parametrize('a,b,expect', [[1, 1, 1], [1000, 1, 1000]],
ids=['int2', 'int_2'])
def test_div_int(self, a, b, expect):
assert expect == (self.calc.div(a, b))
@pytest.mark.parametrize('a,b,expect', [[0.4, 0.2, 0.2], [10, 1, 10]],
ids=['float2', 'float2_2'])
def test_div_float(self, a, b, expect):
assert expect == self.calc.div(a, b)
@pytest.mark.parametrize('a,b,expect', [[0, 1, 0], [10, 0, 0]],
ids=['zero1', 'zero2'])
def test_div_zero(self, a, b, expect):
assert expect == self.calc.div(a, b)
@pytest.mark.parametrize('a,b,expect', [[1, 1, 1], [1000, 1, 1000]],
ids=['int3', 'int_3'])
def test_mul_int(self, a, b, expect):
assert expect == self.calc.mul(a, b)
@pytest.mark.parametrize('a,b,expect', [[0.4, 0.2, 0.08], [10, 1, 10]],
ids=['float3', 'float_3'])
def test_mul_float(self, a, b, expect):
assert expect == round(self.calc.mul(a, b), 2)
class Testcalculator:
def setup_class(self):
print('\n开始执行测试用例')
self.cal= Calculator()
def teardown_class(self):
print('所有测试用例已执行完毕')
def setup(self):
print('\n开始计算...')
def teardown(self):
print('结束计算！！！')
@pytest.mark.parametrize('a,b,expect',yaml.safe_load(open('./test_add.yaml')))
def test_add(self,a,b,expect):
result = self.cal.add(a,b)
print('\n预期计算结果为：{}'.format(expect))
print('实际计算结果为：{}'.format(result))
assert expect == result
@pytest.mark.parametrize('a,b,expect',yaml.safe_load(open('./test_div.yaml')))
def test_div(self,a,b,expect):
result = self.cal.div(a,b)
if not isinstance(result,str):
result = round(result,2)
expect = round(result,2)
print('\n预期计算结果为：{}'.format(expect))
print('实际计算结果为：{}'.format(result))
assert expect == result
def test_logger_writes_result():
logger = Mock()
calcer = Calculator(logger)
total = calcer.add("1,2,3")
logger.write.assert_called_with(total)
def test_add():
# assert True
calculator = Calculator()
result = calculator.add(2, 3)
assert result == 5
def calc():
calc_obj = Calculator()
a = 2
b = 0
print(calc_obj)
for a, b in zip([1, 2, 3], [4, 5, 6]):
print("=" * 10)
print("a", a)
print("b", b)
print('add', calc_obj.add(a, b))
print('sub', calc_obj.sub(a, b))
print('mul', calc_obj.mul(a, b))
try:
print('div_floor', calc_obj.div_floor(a, b))
print('div', calc_obj.div(a, b))
except CalculatorZeroException as ex:
print(ex)
break
print('power', calc_obj.pow(a, b))
else:
print("No break")
i = 5
while(i):
i -= 1
print(i)
break
else:
print("No break")
def test_result_also_to_stdout():
calcer = Calculator()
total = calcer.add("1,2,3")
out = sys.stdout.getvalue()
assert total == int(out)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_addition(self):
test_data = CsvReader('csvFiles/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_subtraction(self):
test_data = CsvReader('csvFiles/subtraction.csv').data
for row in test_data:
self.assertEqual(
self.calculator.subtract(int(row['Value 1']),
int(row['Value 2'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_multiplication(self):
test_data = CsvReader('csvFiles/multiplication.csv').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('csvFiles/division.csv').data
for row in test_data:
self.assertEqual(
self.calculator.divide(int(row['Value 1']),
int(row['Value 2'])),
format(float(row['Result']), '.7f'))
self.assertEqual(self.calculator.result,
format(float(row['Result']), '.7f'))
def test_square(self):
test_data = CsvReader('csvFiles/square.csv').data
for row in test_data:
self.assertEqual(self.calculator.square(int(row['Value 1'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_square_root(self):
test_data = CsvReader('csvFiles/squareRoot.csv').data
for row in test_data:
self.assertEqual(self.calculator.square_root(int(row['Value 1'])),
format(float(row['Result']), '.7f'))
self.assertEqual(self.calculator.result,
format(float(row['Result']), '.7f'))
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
def main():
while True:
numbers_list = []
while True:
number_prompt = float(
input(
"Enter a number into the calculator: \nEnter 0.0 to move to arithmetic functions\n"
))
if number_prompt == 0.0:
break
numbers_list.append(number_prompt)
print("\n")
calc = Calculator(numbers_list)
prompt_answer = artithmetic_prompt()
if prompt_answer == 1:
result = calc.add()
print("The result was: ", result)
elif prompt_answer == 2:
result = calc.subtract()
print("The result was: ", result)
elif prompt_answer == 3:
result = calc.multiply()
print("The result was: ", result)
elif prompt_answer == 4:
result = calc.division()
print("The result was: ", result)
if not reprompt():
break
class CalTestCase(unittest.TestCase):
"""计算器类测试样例"""
# 程序最开始执行一次
@classmethod
def setUpClass(cls):
print('setUpClass')
# 程序最后执行一次
@classmethod
def tearDownClass(cls):
print('tearDownClass')
# setup准备环境
def setUp(self):
print('New a Cal')
self.cal = Calculator()
# 结束一个测试样例的动作，清理测试造成的影响（清理内存，打印错误啥的）
def tearDown(self):
print('End')
def test_add(self):
'''测试计算器加法'''
result = self.cal.add(3, 5)
expect = 8
self.assertEquals(result, expect)
# @unittest.skip('方法未执行')
@unittest.skipIf(True, "不执行原因")
def test_div(self):
'''测试计算器除法'''
result = self.cal.div(3, 5)
expect = 0.6
self.assertEquals(result, expect)
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):
self.test_data = CsvReader('/src/Subtraction.csv').data
for row in self.test_data:
self.assertEqual(self.calculator.subtract(int(row['Value 1']), int(row['Value 2'])), int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
print(self.calculator.result)
print("------------------Subtraction-------------------")
def test_multiplication(self):
self.test_data = CsvReader('/src/Multiplication.csv').data
for row in self.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']))
print(self.calculator.result)
print("------------------Multiplication-------------------")
def test_divide(self):
self.test_data = CsvReader('/src/Division.csv').data
for row in self.test_data:
self.assertAlmostEqual(self.calculator.division(int(row['Value 1']), int(row['Value 2'])), float(row['Result']))
self.assertAlmostEqual(self.calculator.result, float(row['Result']))
print(self.calculator.result)
print("------------------Division-------------------")
def test_square(self):
self.test_data = CsvReader('/src/Square.csv').data
for row in self.test_data:
self.calculator.square(int(row['Value 1']))
self.assertAlmostEqual(self.calculator.result, int(row['Result']))
print(self.calculator.result)
print("------------------Square-------------------")
def test_squareroot(self):
self.test_data = CsvReader('/src/SquareRoot.csv').data
for row in self.test_data:
self.calculator.squareroot(int(row['Value 1']))
#self.assertAlmostEqual(self.calculator.result, int(row['Result']))
print(self.calculator.result)
print("------------------SquareRoot-------------------")
def test_addition(self):
self.test_data = CsvReader('/src/Addition.csv').data
for row1 in self.test_data:
result1 = float(row1['Result'])
self.assertEqual(self.calculator.add(int(row1['Value 1']), int(row1['Value 2'])), int(row1['Result']))
self.assertEqual(self.calculator.result, int(row1['Result']))
print(self.calculator.result)
print("------------------Addition-------------------")
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_properties(self):
self.assertEqual(self.calculator.result, 0)
def test_addition_calculator(self):
self.assertEqual(self.calculator.add(2, 2), 4)
self.assertEqual(self.calculator.result, 4)
def test_subtraction_calculator(self):
self.assertEqual(self.calculator.subtract(2, 2), 0)
self.assertEqual(self.calculator.result, 0)
def test_multiplication_calculator(self):
self.assertEqual(self.calculator.multiply(2, 2), 4)
self.assertEqual(self.calculator.result, 4)
def test_division_calculator(self):
self.assertEqual(self.calculator.divide(2, 2), 1)
self.assertEqual(self.calculator.result, 1)
def test_square_calculator(self):
self.assertEqual(self.calculator.squared(2), 4)
self.assertEqual(self.calculator.result, 4)
def test_squareroot_calculator(self):
self.assertEqual(self.calculator.sqrt(9), 3)
self.assertEqual(self.calculator.result, 3)
class CountTest(unittest.TestCase):
# setUp()方法用于测试用例执行前的初始化工作，例如初始化变量、生成数据库测试数据、打开浏览器等
def setUp(self):
self.cal = Calculator(8, 4)
# tearDown()方法与setUp()方法相呼应，用于测试用例执行之后的善后工作，例如清除数据库测试数据、关闭文件、关闭浏览器等
def tearDown(self):
pass
# unittest 要求测试方法必须以“test”开头。例如，test_add、test_sub 等
def test_add(self):
result = self.cal.add()
self.assertEqual(result, 12)
def test_sub(self):
result = self.cal.sub()
self.assertEqual(result, 4)
def test_mul(self):
result = self.cal.mul()
self.assertEqual(result, 32)
def test_div(self):
result = self.cal.div()
self.assertEqual(result, 2)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def tearDown(self):
if CsvReader.data is not None:
CsvReader.data = []
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property_calculator(self):
self.assertEqual(self.calculator.result, 0)
def test_add_method_calculator(self):
self.test_data = CsvReader('src/td/addition.csv').data
for row in self.test_data:
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_subtract_method_calculator(self):
self.test_data = CsvReader('src/td/subtraction.csv').data
for row in self.test_data:
self.assertEqual(
self.calculator.subtract(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_divide_method_calculator(self):
self.test_data = CsvReader('src/td/division.csv').data
for row in self.test_data:
self.assertEqual(
self.calculator.divide(row['Value 1'], row['Value 2']),
Decimal(row['Result']))
self.assertEqual(self.calculator.divide('0', row['Value 2']),
'error, the divisor can not be zero')
def test_multiply_method_calculator(self):
self.test_data = CsvReader('src/td/multiplication.csv').data
for row in self.test_data:
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
Decimal(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_square_method_calculator(self):
self.test_data = CsvReader('src/td/square.csv').data
for row in self.test_data:
self.assertEqual(self.calculator.square(row['Value 1']),
Decimal(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_square_root_method_calculator(self):
self.test_data = CsvReader('src/td/squareRoot.csv').data
for row in self.test_data:
self.assertEqual(self.calculator.square_root(row['Value 1']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
class TestCalc:
def setup_class(self):
print("\n计算开始")
self.calc = Calculator()
def teardown_class(self):
print("\n计算结束")
@pytest.mark.parametrize("a,b,expect", get_datas()[0])
def test_add(self, a, b, expect):
result = self.calc.add(a, b)
if result == expect:
print("\n加法结果与期望值相等")
else:
print("\n加法结果与期望值不相等")
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:
# 变量后加:类型提示作用
# datas:list = get_datas()
add_int_data = get_datas("add", "int")
add_float_data = get_datas("add", "float")
div_int_data = get_datas("div", "int")
div_zero_data = get_datas("div", "zero")
# 前置条件
def setup(self):
print("开始计算")
# 实例变量
self.calc = Calculator()
def teardown(self):
print("结束计算")
@pytest.mark.add_normal
# 参数化每一条用例是独立的，某一条失败不影响其他条
@pytest.mark.parametrize("a,b,result",
add_int_data[0],
ids=add_int_data[1])
def test_add(self, a, b, result):
print(a, b, result)
assert result == self.calc.add(a, b)
@pytest.mark.add_float
@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), 2)
@pytest.mark.div
@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.div_zero
@pytest.mark.parametrize("a,b,result",
div_zero_data[0],
ids=div_zero_data[1])
def test_div(self, a, b, result):
with pytest.raises(ZeroDivisionError):
result = a / b
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_addition(self):
test_data = csvreader('TestAddition.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
def test_subtraction(self):
test_data = csvreader('TestSubtraction.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.subtract(row['Value 1'], row['Value 2']),
result)
self.assertEqual(self.calculator.result, result)
def test_times(self):
test_data = csvreader('TestMultiplication.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
result)
self.assertEqual(self.calculator.result, result)
def test_div(self):
test_data = csvreader('TestDivision.csv').data
for row in test_data:
result = float(row['Result'])
self.assertAlmostEqual(
self.calculator.division(row['Value 1'], row['Value 2']),
result)
self.assertAlmostEqual(self.calculator.result, result)
def test_square(self):
test_data = csvreader('TestSquare.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.square(row['Value 1']), result)
self.assertEqual(self.calculator.result, result)
def test_sqrt(self):
test_data = csvreader('TestSquareRoot.csv').data
for row in test_data:
result = float(row['Result'])
self.assertAlmostEqual(self.calculator.sqrt(row['Value 1']),
result)
self.assertAlmostEqual(self.calculator.result, result)
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
class CsvReaderTests(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_csvreader(self):
self.csv_reader = CsvReader('data/Unit Test CsvReader.txt')
self.assertIsInstance(self.csv_reader, CsvReader)
self.assertEqual(self.csv_reader.data.__len__(), 2)
def test_add(self):
test_data = CsvReader('data/Unit Test Addition.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']), result)
def test_subtract(self):
test_data = CsvReader('data/Unit Test Subtraction.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.subtract(row['Value 2'], row['Value 1']),
result)
def test_multiply(self):
test_data = CsvReader('data/Unit Test Multiplication.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
result)
def test_division(self):
test_data = CsvReader('data/Unit Test Division.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
round(self.calculator.divide(row['Value 2'], row['Value 1']),
9), result)
def test_square(self):
test_data = CsvReader('data/Unit Test Square.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.square(row['Value 1']), result)
def test_squareroot(self):
test_data = CsvReader('data/Unit Test Square Root.csv').data
for row in test_data:
data = row['Result']
result = float(data)
if "." in data:
sigfigs = len(data.split('.')[1])
self.assertEqual(
round(self.calculator.squareroot(row['Value 1']), sigfigs),
result)
else:
self.assertEqual(self.calculator.squareroot(row['Value 1']),
result)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def tearDown(self):
if self.calculator is not None:
self.calculator = None
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
def test_addition(self):
test_data = CsvReader('/src/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']))
def test_subtraction(self):
test_data = CsvReader('/src/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']))
def test_multiplication(self):
test_data = CsvReader('/src/Multiplication.csv').data
for row in test_data:
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_division(self):
test_data = CsvReader('/src/Division.csv').data
for row in test_data:
self.assertEqual(
self.calculator.divide(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_square(self):
test_data = CsvReader('/src/Square.csv').data
for row in test_data:
self.assertEqual(self.calculator.square(row['Value 1']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_squareRoot(self):
test_data = CsvReader('/src/SquareRoot.csv').data
for row in test_data:
self.assertEqual(self.calculator.squareRoot(row['Value 1']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property_calculator(self):
self.assertEqual(self.calculator.result, 0)
def test_add_method_calculator(self):
test_data_add = CsvReader('/src/Addition.csv').data
for row in test_data_add:
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_subtract_method_calculator(self):
test_data_subtract = CsvReader('/src/Subtraction.csv').data
for row in test_data_subtract:
self.assertEqual(
self.calculator.subtract(int(row['Value 1']),
int(row['Value 2'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_multiplication_method_calculator(self):
test_data_multiplication = CsvReader('/src/Multiplication.csv').data
for row in test_data_multiplication:
self.assertEqual(
self.calculator.multiplication(int(row['Value 1']),
int(row['Value 2'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_division_method_calculator(self):
test_data_division = CsvReader('/src/Division.csv').data
for row in test_data_division:
self.assertEqual(
self.calculator.division(float(row['Value 1']),
float(row['Value 2'])),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_square_method_calculator(self):
test_data_square = CsvReader('/src/Square.csv').data
for row in test_data_square:
self.assertEqual(self.calculator.square(int(row['Value 1'])),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_sqrt_method_calculator(self):
test_data_sqrt = CsvReader('/src/Square Root.csv').data
for row in test_data_sqrt:
self.assertEqual(self.calculator.sqrt(float(row['Value 1'])),
round(float(row['Result']), 8))
self.assertEqual(self.calculator.result,
round(float(row['Result']), 8))
def test_addition(self):
calculator = Calculator()
testData = CsvReader('src/Unit Test Addition.csv'
).data #.return_data_as_objects('addition')
for row in testData:
self.assertEqual(
calculator.add(int(row['Value 1']), int(row['Value 2'])),
int(row['Result']))
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)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property_calculator(self):
self.assertEqual(self.calculator.result, 0)
def test_add_method_calculator(self):
test_data = CsvReader('/src/Unit Test 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']))
def test_subtract_method_calculator(self):
test_data = CsvReader('/src/Unit Test 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']))
def test_multiply_method_calculator(self):
test_data = CsvReader('/src/Unit Test Multiplication.csv').data
for row in test_data:
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_divide_method_calculator(self):
test_data = CsvReader('/src/Unit Test 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']))
def test_sqr_method_calculator(self):
test_data = CsvReader('/src/Unit Test Square.csv').data
for row in test_data:
self.assertEqual(self.calculator.square(row['Value 1'], ),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_sqrroot_method_calculator(self):
test_data = CsvReader('/src/Unit Test Square Root.csv').data
for row in test_data:
self.assertAlmostEqual(
self.calculator.squareroot(row['Value 1'], ),
float(row['Result']))
self.assertAlmostEqual(self.calculator.result,
float(row['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/Subtraction.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.subtract(float(row['Value 1']),
float(row['Value 2'])), result)
self.assertEqual(self.calculator.result, result)
def test_addition(self):
test_data = CsvReader('/src/Addition.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.add(float(row['Value 1']),
float(row['Value 2'])), result)
self.assertEqual(self.calculator.result, result)
def test_multiplication(self):
test_data = CsvReader('/src/Multiplication.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.multiply(float(row['Value 1']),
float(row['Value 2'])), result)
self.assertEqual(self.calculator.result, result)
def test_division(self):
test_data = CsvReader('/src/Division.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.divide(float(row['Value 1']),
float(row['Value 2'])), result)
self.assertEqual(self.calculator.result, result)
def test_square(self):
test_data = CsvReader('/src/Square.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.sqr(float(row['Value 1'])),
result)
self.assertEqual(self.calculator.result, result)
def test_squareroot(self):
test_data = CsvReader('/src/SquareRoot.csv').data
for row in test_data:
result = round(float(row['Result']), 8)
self.assertEqual(self.calculator.sqrt(float(row['Value 1'])),
result)
self.assertEqual(self.calculator.result, result)
class testCalculator(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_should_check_if_number_is_valid(self):
self.assertEqual(self.calculator.isInvalidNumber(1), False)
def test_should_check_if_number_is_invalid(self):
self.assertEqual(self.calculator.isInvalidNumber("Invalid Number"), True)
def test_should_add_two_numbers_if_are_valid(self):
self.assertEqual(self.calculator.add(1, 2), 3)
def test_should_return_zero_if_1st_number_is_invalid(self):
self.assertEqual(self.calculator.add("Invalid Number", 2), "Zero")
def test_should_return_zero_if_2nd_number_is_invalid(self):
self.assertEqual(self.calculator.add(2, "Invalid Number"), "Zero")
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_addition_calculator(self):
test_data = CsvReader('/src/Addition.csv').data
pprint(test_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']))
def test_results_subtraction_calculator(self):
test_data = CsvReader('/src/Subtraction.csv').data
pprint(test_data)
for row in test_data:
self.assertEqual(
self.calculator.subtract(row['Value 2'], row['Value 1']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_multiplication_method_calculator(self):
test_data = CsvReader('/src/Multiplication.csv').data
pprint(test_data)
for row in test_data:
self.assertEqual(
self.calculator.multiplication(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_division_method_calculator(self):
test_data = CsvReader('/src/Division.csv').data
pprint(test_data)
for row in test_data:
self.assertEqual(
self.calculator.division(row['Value 2'], row['Value 1']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_square_method_calculator(self):
test_data = CsvReader('/src/Unit_square.csv').data
pprint(test_data)
for row in test_data:
self.assertEqual(self.calculator.square(row['Value 1']),
float(row['Result']))
def test_squareRoot_method_calculator(self):
test_data = CsvReader('/src/Unit_test_square_root.csv').data
pprint(test_data)
for row in test_data:
self.assertEqual(self.calculator.squareRoot(row['Value 1']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property_calculator(self):
self.assertEqual(self.calculator.result, 4)
def test_addition_method_calculator(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Calculator.csv").data
for row in test_data:
result = float(row['Add Result'])
self.assertEqual(self.calculator.add(row['Add 1'], row['Add 2']), result)
self.assertEqual(self.calculator.result, result)
def test_subtraction(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Calculator.csv").data
for row in test_data:
result = float(row['Sub Result'])
self.assertEqual(self.calculator.subtract(row['Sub 1'], row['Sub 2']), float(row['Sub Result']))
self.assertEqual(self.calculator.result, result)
def test_multiplication(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Calculator.csv").data
for row in test_data:
result = float(row['Multiply Result'])
self.assertEqual(self.calculator.multiply(row['Multiply 1'], row['Multiply 2']),
float(row['Multiply Result']))
self.assertEqual(self.calculator.result, result)
def test_division(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Calculator.csv").data
for row in test_data:
result = float(row['Divide Result'])
self.assertEqual(self.calculator.divide(row['Divide 1'], row['Divide 2']), float(row['Divide Result']))
self.assertEqual(self.calculator.result, result)
def test_squared(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Calculator.csv").data
for row in test_data:
result = float(row['Squared Result'])
self.assertEqual(self.calculator.squared(row['Squared 1']), float(row['Squared Result']))
self.assertEqual(self.calculator.result, result)
def test_sqrt(self):
test_data = CsvReader("/CSVFiles/Unit_Test_Calculator.csv").data
for row in test_data:
result = float(row['Sqrt Result'])
self.assertEqual(self.calculator.sqrt(row['Sqrt 1']), float(row['Sqrt Result']))
self.assertEqual(self.calculator.result, result)
def test_results_property(self):
self.assertEqual(self.calculator.result, 4)
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: ")
print div1, "/", div2, "=", calc.divide(div1, div2)
elif choice == 5:
loop = 0
print "Bye"
def test_FivePlusFiveIsTen(self):
five = Calculator(5)
self.assertEqual(10, five.add(5))
def test_ZeroPlusZeroIsZero(self):
zero = Calculator(0)
self.assertEqual(0, zero.add(0))
class CalcTest(unittest.TestCase): # This function references the Calculator object so the subsequent tests can run properly # def setUp(self): self.calc = Calculator() # This tests the add function: # 2 + 2 = 4 # 2 + 6 = 8 # 8.5 + 6.5 = 15 # 6 + (-2) = 4 def testadd(self): operation = self.calc.add(2,2) self.assertEqual(4, operation) operation = self.calc.add(2,6) self.assertEqual(8, operation) operation = self.calc.add(8.5,6.5) self.assertEqual(15, operation) operation = self.calc.add(6,-2) self.assertEqual(4, operation) # This tests the substract function: # 4 - 2 = 2 # 2 - 2 = 0 # 10 - 5 = 5 # 4 - 0 = 4 # 5 - (-5) = 10 # 6.5 - 3.5 = 3 def testsubstract(self): operation = self.calc.substract(4,2) self.assertEqual(2, operation) operation = self.calc.substract(2,2) self.assertEqual(0, operation) operation = self.calc.substract(10,5) self.assertEqual(5, operation) operation = self.calc.substract(4,0) self.assertEqual(4, operation) operation = self.calc.substract(5,-5) self.assertEqual(10, operation) operation = self.calc.substract(6.5,3.5) self.assertEqual(3, operation) # This tests the multiply function: # 2 x 2 = 4 # 9 x 2 = 18 # 3 x 0 = 0 # 12 x 0.5 = 6 # 2 x (-4) = -8 def testmultip(self): operation = self.calc.multip(2,2) self.assertEqual(4, operation) operation = self.calc.multip(9,2) self.assertEqual(18, operation) operation = self.calc.multip(3,0) self.assertEqual(0, operation) operation = self.calc.multip(12,0.5) self.assertEqual(6, operation) operation = self.calc.multip(2,-4) self.assertEqual(-8, operation) # This tests the divide function: # 4 / 2 = 2 # 15 / 2.0 = 7.5 # 5 / 0 = None # 7 / (-7) = -1 def testdivide(self): operation = self.calc.divide(4,2) self.assertEqual(2, operation) operation = self.calc.divide(15,2.0) self.assertEqual(7.5, operation) operation = self.calc.divide(5,0) self.assertEqual(None, operation) operation = self.calc.divide(7,-7) self.assertEqual(-1, operation) # This tests the square function: # 2^2 = 4 # 3^2 = 9 # 0^2 = 0 # -1^2 = 1 # 5.5^2 = 30.25 # 1^2 = 1 def testsquare(self): self.assertEqual(4, self.calc.square(2)) self.assertEqual(9, self.calc.square(3)) self.assertEqual(0, self.calc.square(0)) self.assertEqual(1, self.calc.square(-1)) self.assertEqual(100, self.calc.square(10)) self.assertEqual(30.25, self.calc.square(5.5)) self.assertEqual(1, self.calc.square(1)) # This tests the cube function: # 2^3 = 8 # 3^3 = 27 # 0^3 = 0 # -1^3 = -1 # 5.5^3 = 166.375 # 1^3 = 1 def testcube(self): self.assertEqual(8, self.calc.cube(2)) self.assertEqual(27, self.calc.cube(3)) self.assertEqual(0, self.calc.cube(0)) self.assertEqual(-1, self.calc.cube(-1)) self.assertEqual(1000, self.calc.cube(10)) self.assertEqual(166.375, self.calc.cube(5.5)) self.assertEqual(1, self.calc.cube(1)) # This tests the exponential function: # 2^2 = 4 # 2^0 = 1 # 2^-1 = 0.5 # -8^5 = -32768 # -8^4 = 4096 def testexp(self): operation = self.calc.exp(2,2) self.assertEqual(4, operation) operation = self.calc.exp(2,0) self.assertEqual(1, operation) operation = self.calc.exp(2,-1) self.assertEqual(0.5, operation) operation = self.calc.exp(-8,5) self.assertEqual(-32768, operation) operation = self.calc.exp(-8,4) self.assertEqual(4096, operation) # This tests the factorial function: # 2! = 2 # 3! = 6 # 0! = 1 # -1! = None # 10! = 3628800 # 5.5! = 120 (it is converted to 5 integer) # 1! = 1 def testfactorial(self): self.assertEqual(2, self.calc.factorial(2)) self.assertEqual(6, self.calc.factorial(3)) self.assertEqual(1, self.calc.factorial(0)) self.assertEqual(None, self.calc.factorial(-1)) self.assertEqual(3628800, self.calc.factorial(10)) self.assertEqual(120, self.calc.factorial(5.5)) self.assertEqual(1, self.calc.factorial(1)) # This tests the square root function: # sqrt(4) = 2 # sqrt(9) = 3 # sqrt(0) = 0 # sqrt(1) = 1 # sqrt(100) = 10 # sqrt(30.25) = 5.5 # sqrt(-1) = None def testsqrt(self): self.assertEqual(2, self.calc.sqrt(4)) self.assertEqual(3, self.calc.sqrt(9)) self.assertEqual(0, self.calc.sqrt(0)) self.assertEqual(1, self.calc.sqrt(1)) self.assertEqual(10, self.calc.sqrt(100)) self.assertEqual(5.5, self.calc.sqrt(30.25)) self.assertEqual(None, self.calc.sqrt(-1)) # This tests the cube root function: # cbrt(8) = 2 # cbrt(27) = 3 # cbrt(0) = 0 # cbrt(-1) = None # cbrt(166.375) = 5.5 # cbrt(1) = 1 def testcbrt(self): self.assertEqual(2, self.calc.cbrt(8)) self.assertEqual(3, self.calc.cbrt(27)) self.assertEqual(0, self.calc.cbrt(0)) self.assertEqual(None, self.calc.cbrt(-1)) self.assertEqual(5.5, self.calc.cbrt(166.375)) self.assertEqual(1, self.calc.cbrt(1))
