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)
