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))