class CalculatorTest(unittest.TestCase): @classmethod def setUpClass(cls): print("in setup class") @classmethod def tearDownClass(cls): print("in tearDown class") def setUp(self): print("in setUp") self.calc = Calculator() def tearDown(self): print("in tearDown") def test_jam(self): a, b = 2, 5 result = self.calc.jam(a, b) self.assertEqual(result, 7) def test_minus(self): a, b = 2, 5 result = self.calc.minus(a, b) self.assertEqual(result, -3)
def test_first_digit_to_second(): assert Calculator.first_digit_to_second(numbers=[3, 2], balance=23234) == 22224 assert Calculator.first_digit_to_second(numbers=[2, 0], balance=22320) == 300 assert Calculator.first_digit_to_second(numbers=[1, 0], balance=1) == 0 assert Calculator.first_digit_to_second(numbers=[1, -5], balance=111) == 555 assert Calculator.first_digit_to_second(numbers=[8, 1], balance=1458182133) == 1451112133
def testUnionTwoStacks(self): for i in range(5): for j in range(5): stack1 = Stack(20) for k in range(10): stack1.push(k+i*100) stack2 = Stack(20) for k in range(10): stack2.push(k+j*1000) resultat = Calculator.union(stack1, stack2) self.assertIsInstance(resultat, Stack) self.assertEqual(resultat.max_size, stack1.max_size + stack2.max_size) self.assertEqual(resultat.size(), stack1.size() + stack2.size()) for k in range(9, -1, -1): self.assertEqual(resultat.pop(), k+j*1000) for k in range(9, -1, -1): self.assertEqual(resultat.pop(), k+i*100)
def testUnionTwoQueues(self): for i in range(5): for j in range(5): queue1 = Queue(20) for k in range(10): queue1.enqueue(k+i*100) queue2 = Queue(20) for k in range(10): queue2.enqueue(k+j*1000) resultat = Calculator.union(queue1, queue2) self.assertIsInstance(resultat, Queue) self.assertEqual(resultat.max_size, queue1.max_size + queue2.max_size) self.assertEqual(resultat.size(), queue1.size() + queue2.size()) for k in range(10): self.assertEqual(resultat.dequeue(), k+i*100) for k in range(10): self.assertEqual(resultat.dequeue(), k+j*1000)
def test_c_UnionStack(self): stack1 = Stack(3) stack2 = Stack(3) numbers = [1, 2, 3, 4, 5, 6] numbersstack1 = [1, 2, 3] numbersstack2 = [4, 5, 6] for i in numbersstack1: stack1.push(i) for i in numbersstack2: stack2.push(i) unitedStack = Calculator.union(stack1, stack2) numbersContained = 0 for i in numbers: number = unitedStack.pop().value if number in numbers: numbersContained += 1 numbers.remove(number) self.assertEqual(numbersContained, len(numbers)) self.assertEqual(unitedStack.max_size, stack1.max_size + stack2.max_size)
def test_b_UnionQueue(self): queue1 = Queue(3) queue2 = Queue(3) numbers = [1, 2, 3, 4, 5, 6] numbersqueue1 = [1, 2, 3] numbersqueue2 = [4, 5, 6] for i in numbersqueue1: queue1.enqueue(i) for i in numbersqueue2: queue2.enqueue(i) unitedStack = Calculator.union(queue1, queue2) numbersContained = 0 for i in numbers: number = unitedStack.dequeue().value if number in numbers: numbersContained += 1 numbers.remove(number) self.assertEqual(numbersContained, len(numbers)) self.assertEqual(unitedStack.max_size, queue1.max_size + queue2.max_size)
def testUnionTwoLinkedLists(self): listes = [] for n in range(5): liste = LinkedList() for i in range(10): liste.append(i + n*100) listes.append(liste) for i in range(len(listes)): for j in range(i): resultat = Calculator.union(listes[i], listes[j]) self.assertIsInstance(resultat, LinkedList) self.assertNotIsInstance(resultat, Stack) self.assertNotIsInstance(resultat, Queue) self.assertEqual(resultat.size(), listes[i].size() + listes[j].size()) for k in range(len(listes)): if k==i: for elem in listes[k].list: self.assertTrue(contient(resultat, elem)) elif k==j: for elem in listes[k].list: self.assertTrue(contient(resultat, elem)) else: for elem in listes[k].list: self.assertFalse(contient(resultat, elem))
class CalculatorTests(unittest.TestCase): def setUp(self): self.calculator = Calculator() def test_calculator_should_instantiate(self): self.assertIsInstance(self.calculator, Calculator) def test_add_should_return_sum_when_given_two_integers(self): result = self.calculator.add(4, 5) expected = 9 self.assertEqual(result, expected) def test_add_should_return_ValueError_when_given_two_strings(self): self.assertRaises(ValueError, self.calculator.add, "ten", "twenty") def test_multiply_should_multiply_numbers_when_given_two_integers(self): result = self.calculator.multiply(3, 5) expected = 15 self.assertEqual(result, expected) def test_multiply_should_return_ValueError_when_given_two_strings(self): self.assertRaises(ValueError, self.calculator.multiply, "five", "ten") def test_subtract_should_subtract_numbers_when_given_two_integers(self): result = self.calculator.subtract(5, 2) expected = 3 self.assertEqual(result, expected) def test_subtract_should_return_ValueError_when_given_two_strings(self): self.assertRaises(ValueError, self.calculator.subtract, "fourty", "one") def test_divide_should_divide_numbers_when_given_two_integers(self): result = self.calculator.divide(10, 5) expected = 2 self.assertEqual(result, expected) def test_divide_should_return_ValueError_when_given_two_strings(self): self.assertRaises(ValueError, self.calculator.divide, "fifteen", "three")
class Tests(unittest.TestCase): def setUp(self): self.calculator = Calculator() def test_calculator_object(self): self.assertIsInstance(self.calculator, Calculator) def test_add_function_exists(self): self.calculator.add def test_add_two_numbers(self): result = self.calculator.add(10,2) expected = 12 self.assertEqual(result, expected) def test_subtract_function_exists(self): self.calculator.subtract def test_subtract_two_numbers(self): result = self.calculator.subtract(10,2) expected = 8 self.assertEqual(result, expected) def test_divide_function_exists(self): self.calculator.divide def test_divide_two_numbers(self): result = self.calculator.divide(10,2) expected = 5 self.assertEqual(result, expected) def test_multiply_function_exists(self): self.calculator.multiply def test_multiply_two_numbers(self): result = self.calculator.multiply(10,2) expected = 20 self.assertEqual(result, expected)
class TddInPythonExample(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_calculator_add_method_returns_correct_result(self): result = self.calc.add(2, 2) self.assertEqual(43, result) def test_calculator_returns_error_message_if_both_args_not_numbers(self): self.assertRaises(ValueError, self.calc.add, 'two', 'three') def test_calculator_returns_error_message_if_x_arg_not_number(self): self.assertRaises(ValueError, self.calc.add, 'two', 3) def test_calculator_returns_error_message_if_y_arg_not_number(self): self.assertRaises(ValueError, self.calc.add, 2, 'three')
def testUnionStackAndQueue(self): stacks = [] for n in range(5): stack = Stack(20) for i in range(10): stack.push(i+n*100) stacks.append(stack) queues = [] for n in range(5): queue = Queue(20) for i in range(10): queue.enqueue(i+n*1000) queues.append(queue) for stack in stacks: for queue in queues: resultat = Calculator.union(stack, queue) self.assertIsInstance(resultat, LinkedList) self.assertNotIsInstance(resultat, Stack) self.assertNotIsInstance(resultat, Queue) self.assertEqual(resultat.size(), stack.size() + queue.size()) noeud = stack.first while noeud.next: self.assertTrue(contient(resultat, noeud.value)) noeud = noeud.next noeud = queue.first while noeud.next: self.assertTrue(contient(resultat, noeud.value)) noeud = noeud.next
def test_remove_digit(): assert Calculator.remove_digit(balance=333) == 33 assert Calculator.remove_digit(balance=0) == 0
def test_multiply(): assert Calculator.multiply(numbers=[2], balance=2) == 4
def test_divide(): assert Calculator.divide(numbers=[8], balance=2) == 0 assert Calculator.divide(numbers=[0.1], balance=10) == 100
def test_calculator_add_method(self): calc = Calculator() result = calc.add(2, 2) self.assertEqual(4, result)
def test_subtract(): assert Calculator.subtract(numbers=[4], balance=10) == 6
def test_a_UnionLinkedList(self): # If list1 is bigger list1 = LinkedList() list2 = LinkedList() numbers = [1, 2, 3, 4, 5] numbersList1 = [1, 2, 3] numbersList2 = [4, 5] for i in numbersList1: list1.append(i) for i in numbersList2: list2.append(i) UnitedList = Calculator.union(list1, list2) numbersContained = 0 for i in numbersList1 + numbersList2: number = UnitedList.peek().value if number in numbersList1 + numbersList2: numbersContained += 1 numbers.remove(number) self.assertEqual(numbersContained, len(numbersList1 + numbersList2)) # If list2 is bigger list1 = LinkedList() list2 = LinkedList() numbers = [1, 2, 3, 4, 5] numbersList1 = [1, 2] numbersList2 = [3, 4, 5] for i in numbersList1: list1.append(i) for i in numbersList2: list2.append(i) UnitedList = Calculator.union(list1, list2) numbersContained = 0 for i in numbersList1 + numbersList2: number = UnitedList.peek().value if number in numbersList1 + numbersList2: numbersContained += 1 numbers.remove(number) self.assertEqual(numbersContained, len(numbersList1 + numbersList2)) # If lists are the same size list1 = LinkedList() list2 = LinkedList() numbers = [1, 2, 3, 4] numbersList1 = [1, 2] numbersList2 = [3, 4] for i in numbersList1: list1.append(i) for i in numbersList2: list2.append(i) UnitedList = Calculator.union(list1, list2) numbersContained = 0 for i in numbersList1 + numbersList2: number = UnitedList.peek().value if number in numbersList1 + numbersList2: numbersContained += 1 numbers.remove(number) self.assertEqual(numbersContained, len(numbersList1 + numbersList2))
def step_impl(context, values): context.calculator = Calculator() context.values = values.split(',')
def test_04_should_return_new_size_of_merged_queue(self): unionList = Calculator.union(self.stack, self.stack) self.assertEqual(unionList.size(), 6)
def setUp(self): print(f"in setUp-{self}") self.calc = Calculator()
def test_sum_numbers(): assert Calculator.sum_numbers(balance=305) == 8 assert Calculator.sum_numbers(balance=0) == 0 assert Calculator.sum_numbers(balance=-60) == 6
def test_add(): assert Calculator.add(numbers=[3], balance=3) == 6 assert Calculator.add(numbers=[0], balance=0) == 0
def setUp(self): self.calculator = Calculator()
class AppTests(unittest.TestCase): def setUp(self): self.calculator = Calculator() def test_calculator_instantiates(self): self.assertIsInstance(self.calculator, Calculator) def test_add_sums_when_numbers(self): result = self.calculator.add(2, 2) expected = 4 self.assertEqual(result, expected) def test_add_rejects_when_string(self): self.assertRaises(ValueError, self.calculator.add, 2, "two") def test_subtract_subtracts_when_numbers(self): result = self.calculator.subtract(2, 2) expected = 0 self.assertEqual(result, expected) def test_subtract_rejects_when_string(self): self.assertRaises(ValueError, self.calculator.subtract, 2, "two") def test_multiply_multiplies_when_numbers(self): result = self.calculator.multiply(2, 2) expected = 4 self.assertEqual(result, expected) def test_multiply_rejects_when_string(self): self.assertRaises(ValueError, self.calculator.add, 2, "two") def test_divide_divides_numbers_when_whole(self): result = self.calculator.divide(2, 2) expected = 1 self.assertEqual(result, expected) def test_divide_returns_decimal_when_not_whole(self): result = self.calculator.divide(3, 2) expected = 1.5 self.assertEqual(result, expected) def test_divide_rejects_when_string(self): self.assertRaises(ValueError, self.calculator.divide, 2, "two") def test_divide_rejects_when_divisor_is_zero(self): self.assertRaises(ZeroDivisionError, self.calculator.divide, 2, 0) def test_simple_divide_returns_quotient_when_whole(self): result = self.calculator.simple_divide(4, 2) expected = 2 self.assertEqual(result, expected) def test_simple_divide_returns_quotient_and_remainder_when_not_whole(self): result = self.calculator.simple_divide(5, 2) expected = 2, 1 self.assertEqual(result, expected) def test_simple_divide_rejects_when_string(self): self.assertRaises(ValueError, self.calculator.simple_divide, 5, "two") def test_simple_divide_rejeects_when_divisor_is_zero(self): self.assertRaises(ZeroDivisionError, self.calculator.simple_divide, 5, 0)
def setUp(self): print("in setUp") self.calc = Calculator()
def test_inverse_x(): assert Calculator.inverse_x(balance=111) == 999 assert Calculator.inverse_x(balance=0) == 10
def test_04_should_return_first_element_of_merged_stack(self): unionList = Calculator.union(self.stack, self.stack) self.assertEqual(unionList.list[0], 15)
def test_insert(): assert Calculator.insert_number(numbers=[2], balance=100) == 1002 assert Calculator.insert_number(numbers=[333], balance=0) == 333
def test_04_should_return_first_element_of_merged_queue(self): unionList = Calculator.union(self.queue, self.queue) self.assertEqual(unionList.first.value, 16)