class Calc0TestCase(unittest.TestCase):
def setUp(self):
self.calc = Calculator(0)
def tearDown(self):
self.calc = None
def testAdd1(self):
assert self.calc.add(1) == 1, "addition is wrong"
def testAdd2(self):
assert self.calc.add(2) == 2, "addition is wrong"
def testSub(self):
assert self.calc.sub(1) == -1, "substraction is wrong"
class Calc1TestCase(unittest.TestCase):
def setUp(self):
self.calc = Calculator(1)
def tearDown(self):
self.calc = None
def testAdd1(self):
assert self.calc.add(1) == 2, "addition is wrong"
def testAdd2(self):
assert self.calc.add(2) == 3, "addition is wrong"
def testSub(self):
assert self.calc.sub(1) == 0, "substraction is wrong"
class TestExample(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def should_return_correct_result(self):
result = self.calc.add(1, 2)
self.assertEqual(3, result)
class CalculatorTest(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_last_answer_init(self):
value = self.calc.last_answer
self.assertEqual(value, 0.0, FAILURE)
def test_add(self):
value = self.calc.add(NUMBER_1, NUMBER_2)
self.assertEqual(value, 6.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_subtract(self):
value = self.calc.subtract(NUMBER_1, NUMBER_2)
self.assertEqual(value, 1.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_subtract_negative(self):
value = self.calc.subtract(NUMBER_2, NUMBER_1)
self.assertEqual(value, -1.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_multiply(self):
value = self.calc.multiply(NUMBER_1, NUMBER_2)
self.assertEqual(value, 6.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_divide(self):
value = self.calc.divide(NUMBER_1, NUMBER_2)
self.assertEqual(value, 1.5, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_divide_by_zero(self):
self.assertRaises(ZeroDivisionError, self.calc.divide, NUMBER_1, 0)
def test_add(self):
"""
Test add function from class Calculator
"""
calcu = Calculator()
result = calcu.add(3, 4)
self.assertEqual(result, 7)
def test_add(self, input_a, input_b, expected_result):
print("test_add()")
print("input_a", input_a)
print("input_b", input_b)
print("expected_result", expected_result)
calc = Calculator()
self.assertEqual(calc.add(input_a, input_b), expected_result)
def main():
"""
main function
realization of calculation of simples operations
"""
#pass
print(__name__)
calc = Calculator()
print(calc.add())
class CalcTestCase(unittest.TestCase):
def setUp(self):
self.C = Calculator()
def test_multiplication_with_ints(self):
self.assertEqual(self.C.multiply(5, 5), 25)
def test_add_with_ints(self):
self.assertEqual(self.C.add(1, 5), 6)
self.assertEqual(self.C.add(2, 2), 4)
def test_div(self):
self.assertEqual(self.C.div(10, 2), 5)
class CalcTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_adds_two_numbers(self):
self.calculator.add(1,1)
self.assertEqual(self.calculator.total, 2)
@unittest.skip("Needs more work")
def test_adds_single_number(self):
calculator = Calculator()
calculator.add(1)
self.assertEqual(calculator.total, 1)
@unittest.expectedFailure
def test_divide_two_numbers(self):
calculator = Calculator()
calculator.divide(1,0)
class CalculatorLibrary(object):
def __init__(self):
self.calc = Calculator()
def calculate(self, input_a, input_b, operation):
if operation == "+":
return self.calc.add(input_a, input_b)
elif operation == "-":
return self.calc.sub(input_a, input_b)
elif operation == "*":
return self.calc.mul(input_a, input_b)
elif operation == "/":
return self.calc.div(input_a, input_b)
else:
raise ValueError("wrong operation")
def main():
print("Hello! Welcome~")
print("Please enter the kind of function you would like to use.")
print("Currently supported functions are: \n" +
list_to_string(FUNCTIONS_SUPPORTED))
sel = input("Select an option: ")
# Apply logic based on selection
if (sel == "add"):
print("Specify two numbers, a and b")
a = input("a: ")
b = input("b: ")
# Cast numbers to float via function, then add
res = Calculator.add(float(a), float(b))
print("Result: " + str(res))
elif (sel == "sub"):
print("Specify two numbers, a and b")
a = input("a: ")
b = input("b: ")
res = Calculator.sub(float(a), float(b))
print("Result " + str(res))
elif (sel == "mul"):
print("Specify two numbers, a and b")
a = input("a: ")
b = input("b: ")
res = Calculator.mul(float(a), float(b))
print("Result " + str(res))
elif (sel == "div"):
print("Specify two numbers, a and b")
a = input("a: ")
b = input("b: ")
res = Calculator.div(float(a), float(b))
print("Result " + str(res))
elif (sel == "power"):
print("Specify two numbers, a and b")
a = input("a: ")
b = input("b: ")
res = Calculator.power(float(a), float(b))
print("Result " + str(res))
else:
print("Function \"" + sel + "\" not implemented.")
class TestCalculator(unittest.TestCase):
@classmethod
def setUpClass(self):
print("Set up class")
self.calc = Calculator()
# Create an instance of the calculator that can be used in all tests
@classmethod
def tearDownClass(self):
print("Tear down class")
def test_add(self):
self.assertEqual(self.calc.add(2, 7), 9)
# Write test methods for subtract, multiply, and divide
def test_subtract(self):
self.assertEqual(self.calc.subtract(7, 2), 5)
def test_multiply(self):
self.assertEqual(self.calc.multiply(2, 4), 8)
def test_divide(self):
self.assertEqual(self.calc.divide(8, 2), 4)
def test_add(self):
# Test Add with simple integers
self.assertAlmostEqual(Calculator.add(2, 2), 4)
self.assertAlmostEqual(Calculator.add(10, 11), 21)
self.assertAlmostEqual(Calculator.add(4, 2), 6)
#!/usr/bin/env python
from calc import Calculator
def assertAlmostEqual(a, b):
""" A function that tests the approximate equality of two floating point numbers. """
assert round(a - b, 7) == 0, "{} is not equal to {}.".format(a, b)
c1 = Calculator() # Create an instance of a calculator
c2 = Calculator(50) # Create another calculator, initialized with 50
# Test individual methods, and that the two instances properly
# track their own state.
c1.add(2)
assertAlmostEqual(c1.result(), 2)
c1.mul(4)
assertAlmostEqual(c1.result(), 8)
c2.add(50)
assertAlmostEqual(c2.result(), 100)
c1.div(8)
assertAlmostEqual(c1.result(), 1)
c1.sub(-3.)
assertAlmostEqual(c1.result(), 4)
c2.div(c1.result())
assertAlmostEqual(c2.result(), 25)
print("All tests passed! You have a working calculator!")
def runTest(self):
calc = Calculator(0)
assert calc.add(1) == 1, "addition is wrong"
def test_add(self):
calc = Calculator()
self.assertEqual(calc.add(5, 2), 7)
def test_add_mock_return_200(self, mock_mul):
mock_mul.return_value = 200
calc = Calculator()
self.assertEqual(calc.add(1, 2), 200)
def test_add(self):
print('Test add(self, num1, num2) ')
calc = Calculator()
result = calc.add(10, 20)
self.assertEqual(result, 30, 'Match expected value')
def test_add_weirder_stuff():
# Exceptions
calculator = Calculator()
with pytest.raises(CalculatorError):
result = calculator.add("two", "three")
def test_add():
calculator = Calculator()
result = calculator.add(2, 3)
assert result == 5
def test_add_normal(self):
calc = Calculator()
self.assertEqual(calc.add(1, 2), 3)
def test_add_mock_return_100(self, mock_add):
mock_add.return_value = 100
calc = Calculator()
self.assertEqual(calc.add(1, 2), 100)
def test_adding_one_and_one_is_two(self):
calc = Calculator()
result = calc.add(1,1)
self.assertEqual(2, result)
class CalculatorTest(unittest.TestCase):
def setUp(self):
self.calc = Calculator()
def test_last_answer_init(self):
value = self.calc.last_answer
self.assertEqual(value, 0.0, FAILURE)
def test_add(self):
value = self.calc.add(NUMBER_1, NUMBER_2)
self.assertEqual(value, 5.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_subtract(self):
value = self.calc.subtract(NUMBER_1, NUMBER_2)
self.assertEqual(value, 1.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_subtract_negative(self):
value = self.calc.subtract(NUMBER_2, NUMBER_1)
self.assertEqual(value, -1.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_multiply(self):
value = self.calc.multiply(NUMBER_1, NUMBER_2)
self.assertEqual(value, 6.0, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_divide(self):
value = self.calc.divide(NUMBER_1, NUMBER_2)
self.assertEqual(value, 1.5, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_divide_by_zero(self):
self.assertRaises(ZeroDivisionError, self.calc.divide, NUMBER_1, 0)
def test_max_greater(self):
value = self.calc.maximum(NUMBER_1, NUMBER_2)
self.assertEqual(value, NUMBER_1, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_max_less(self):
value = self.calc.maximum(NUMBER_2, NUMBER_1)
self.assertEqual(value, NUMBER_1, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_max_equal(self):
value = self.calc.maximum(NUMBER_1, NUMBER_1)
self.assertEqual(value, NUMBER_1, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_min_greater(self):
value = self.calc.minimum(NUMBER_1, NUMBER_2)
self.assertEqual(value, NUMBER_2, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_min_less(self):
value = self.calc.minimum(NUMBER_2, NUMBER_1)
self.assertEqual(value, NUMBER_2, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_min_equal(self):
value = self.calc.minimum(NUMBER_2, NUMBER_2)
self.assertEqual(value, NUMBER_2, FAILURE)
self.assertEqual(value, self.calc.last_answer, FAILURE)
def test_force_value(self):
self.calc._last_answer = 5
value = self.calc._last_answer
self.assertEqual(value, 5, FAILURE)
def tearDown(self):
pass
def test_add():
calc = Calculator()
assert calc.add(5, 5) == 10
assert calc.add(5, -5) == 0
assert calc.add(5, '$') == 'invalid input'
def test_adds_single_number(self):
calculator = Calculator()
calculator.add(1)
self.assertEqual(calculator.total, 1)
def add(self, argA, argB):
# Import Calculator:
from calc import Calculator
pyCalc = Calculator()
valSum = pyCalc.add(argA, argB)
return valSum
from calc import Calculator from calc import Advanced_calculator my_calc = Calculator() print(my_calc.add(5,4)) print(my_calc.add(4,6)) print(my_calc.history) print(my_calc.result) my_calc.memory_save() print (my_calc.memory) print(my_calc.add(4,None)) print(my_calc.mul(5,4)) print(my_calc.div(7,6)) print(my_calc.sub(10,6)) print(my_calc.div(7,0)) print(my_calc.history) my_calc.clear_history() print(my_calc.history) my_calc.memory_save() print (my_calc.memory, " add") my_calc.clear_memory() print (my_calc.memory, " clear") print(my_calc.sub(10,15))
def runTest(self):
calc = Calculator(0)
assert calc.add(1) == 1, "addition is wrong"
