def test_simplify_fraction(self): #ARRANGE e = None fraction1 = (16, -80) fraction2 = (-183, -669) fraction3 = (-500, 2005) fraction4 = (9000, 666) fraction5 = (2, 8) expected1 = (1,-5) expected2 = (-61,-223) expected3 = (-100, 401) expected4 = (500, 37) expected5 = (1, 4) #ACT try: result1 = simplify_fraction(fraction1) result2 = simplify_fraction(fraction2) result3 = simplify_fraction(fraction3) result4 = simplify_fraction(fraction4) result5 = simplify_fraction(fraction5) except Exception as exc: e = exc #ASSERT self.assertIsNone(e) self.assertEqual(expected1, result1) self.assertEqual(expected2, result2) self.assertEqual(expected3, result3) self.assertEqual(expected4, result4) self.assertEqual(expected5, result5)
def test_when_denominator_equal_0_should_return_exception(self):
fraction = (10, 0)
exc = None
try:
simplify_fraction(fraction)
except Exception as e:
exc = e
self.assertIsNotNone(exc)
self.assertEqual(str(exc), 'Dividing by zero.')
def test_22_3rds(self):
fraction = (462, 63)
result = simplify_fraction(fraction)
expected = (22, 3)
self.assertEqual(result, expected)
def test_when_nominator_bigger_than_denominator_and_reducible(self):
fraction = (9, 3)
result = simplify_fraction(fraction)
expected = (3, 1)
self.assertEqual(result, expected)
def test_when_nominator_smaller_than_denominator_and_reducible(self):
fraction = (3, 9)
result = simplify_fraction(fraction)
expected = (1, 3)
self.assertEqual(expected, result)
def test_3_9ths(self):
fraction = (3, 9)
result = simplify_fraction(fraction)
expected = (1, 3)
self.assertEqual(result, expected)
def test_when_nominator_equals_denominator_then_return_1(self):
fraction = (19, 19)
expected = (1, 1)
result = simplify_fraction(fraction)
self.assertEqual(result, expected)
def test_when_nominator_smaller_than_denominator_but_not_fully_reducible(
self):
fraction = (63, 462)
result = simplify_fraction(fraction)
expected = (3, 22)
self.assertEqual(result, expected)
def test_when_nominator_bigger_than_denominator_but_not_fully_reducible(
self):
fraction = (462, 63)
result = simplify_fraction(fraction)
expected = (22, 3)
self.assertEqual(result, expected)
def collect_fractions(fractions):
frac1 = normalize_fractions(fractions)[0]
frac2 = normalize_fractions(fractions)[1]
summa = sum_normalized_fractions(frac1, frac2)
return simplify_fraction(summa)
def test_when_nominator_is_smaller_than_denominator_and_simplifiable_then_simplify(
self):
fraction = (20, 35)
expected = (4, 7)
result = simplify_fraction(fraction)
self.assertEqual(result, expected)
def test_when_nominator_is_smaller_than_denominator_and_unsimplifiable_then_return_the_same(
self):
fraction = (9, 44)
expected = (9, 44)
result = simplify_fraction(fraction)
self.assertEqual(result, expected)
def test_when_nominator_is_bigger_than_denominator_and_simplifiable_then_simplify(
self):
fraction = (108, 12)
expected = (9, 1)
result = simplify_fraction(fraction)
self.assertEqual(result, expected)
def collect_fractions(fractions): if not fractions: return 0 valid_fractions = ensure_fractions(fractions) sum_of_fractions = sum_of_fractions(valid_fractions) return simplify_fraction(sum_of_fractions)
def collect_fractions(fractions):
if validate_fractions(fractions):
list_of_nominators = [i[0] for i in fractions]
list_of_denominators = [i[1] for i in fractions]
lcm = find_lcm_of_numbers(list_of_denominators)
list_of_nominators = modify_nominators(list_of_nominators,
list_of_denominators, lcm)
return simplify_fraction(((sum(list_of_nominators), lcm)))
else:
raise ValueError('Invalid fractions given!')
def collect_fractions(fractions): n = 0 d = 1 for fraction in fractions: d *= fraction[1] for fraction in fractions: n += fraction[0] * (d // fraction[1]) return simplify_fraction((n, d))
def sum_of_two_fractions(frac1, frac2):
denominator = gcd(frac1[1], frac2[1])
denominator = (frac1[1] * frac2[1]) // denominator
nominator = (frac1[0] * (denominator // frac1[1]) + frac2[0] * (denominator // frac2[1]))
res = simplify_fraction((nominator, denominator))
if str(res) == 'Cannot divide by zero':
raise ZeroDivisionError('Cannot divide by zero')
else:
return res
def collect_fractions(fractions):
validate_input_collect(fractions)
lcmultiplier = 0
length = len(fractions)
if length == 1:
return simplify_fraction(fractions[0])
for index in range(0, length - 1):
pretender = lcm(fractions[index][1], fractions[index + 1][1])
if pretender > lcmultiplier:
lcmultiplier = pretender
sum = 0
for elem in fractions:
if elem[0] != 0:
sum += elem[0] * (lcmultiplier // elem[1])
return simplify_fraction((sum, lcmultiplier))
def test_with_passed_zero_denominator(self): #ARRANGE e = None fraction = (17, 0) #ACT try: result = simplify_fraction(fraction) except Exception as exc: e = exc #ASSERT self.assertIsNotNone(e) self.assertEqual(str(e), "Zero division!")
def test_with_zero_numerator(self): #ARRANGE e = None fraction = (0, 17) expected = (0,) #ACT try: result = simplify_fraction(fraction) except Exception as exc: e = exc #ASSERT self.assertIsNone(e) self.assertEqual(expected, result)
def test_with_no_arguments(self): #ARRANGE e = None empty_tuple = tuple() expected = (0,) #ACT try: result = simplify_fraction(empty_tuple) except Exception as exc: e = exc #ASSERT self.assertIsNone(e) self.assertEqual(expected, result)
def test_with_one_argument(self): #ARRANGE e = None fraction = (6,) expected = (6,) #ACT try: result = simplify_fraction(fraction) except Exception as exc: e = exc #ASSERT self.assertIsNone(e) self.assertEqual(expected, result)
def test_denum_zero(self):
with self.assertRaises(ZeroDivisionError):
simplify_fraction((1000, 0))
def test_denum_zero(self):
with self.assertRaises(ZeroDivisionError):
simplify_fraction((1000, 0))
def test_validate_fraction_object_is_a_tuple(self):
expr = [1, 2]
self.assertRaises(Exception, simplify_fraction(expr))
def test_when_number_is_not_imaculate_then_return_the_simplified_number3(self):
expr = (5, 6)
expected_result = (5, 6)
self.assertEqual(simplify_fraction(expr), expected_result)
def test_different_fractions(self):
self.assertEqual(simplify_fraction((10, 20)), (1, 2))
self.assertEqual(simplify_fraction((63, 462)), (3, 22))
self.assertEqual(simplify_fraction((3, 3)), (1, 1))
def test_simplify_fraction_2(self):
self.assertEqual(simplify_fraction((11, 44)), (1, 4))
def test_one(self):
self.assertEqual((1, 3), simplify_fraction((3, 9)))
def test_zero_denominator(self):
with self.assertRaises(ZeroDivisionError):
simplify_fraction((0, 0))
def test_simplify_fraction(self):
self.assertEqual((1, 3), simplify_fraction((3, 9)))
self.assertEqual((1, 7), simplify_fraction((1, 7)))
self.assertEqual((2, 5), simplify_fraction((4, 10)))
self.assertEqual((3, 22), simplify_fraction((63, 462)))
def test_b_grather_than_a(self):
result = simplify_fraction((6, 2))
test = (3, 1)
self.assertEqual(result, test)
def test_a_equal_b(self):
result = simplify_fraction((6, 6))
test = (1, 1)
self.assertEqual(result, test)
def test_zero_denominator(self):
with self.assertRaises(ZeroDivisionError):
simplify_fraction((0, 0))
def test_two(self):
self.assertEqual((1, 7), simplify_fraction((1, 7)))
def test_simplify_fraction(self):
self.assertEqual(simplify_fraction((63, 462)), (3, 22))
def test_when_the_denominator_is_zero(self):
expr = (1, 0)
self.assertRaises(Exception, simplify_fraction(expr))
def test_three(self):
self.assertEqual((2, 5), simplify_fraction((4, 10)))
def test_a_grather_than_b(self):
result = simplify_fraction((2, 6))
test = (1, 3)
self.assertEqual(result, test)
def test_cases(self):
self.assertEqual((1, 3), simplify_fraction((3, 9)))
self.assertEqual((1, 7), simplify_fraction((1, 7)))
self.assertEqual((2, 5), simplify_fraction((4, 10)))
self.assertEqual((3, 22), simplify_fraction((63, 462)))
def test_four(self):
self.assertEqual((3, 22), simplify_fraction((63, 462)))
def test_simplified_fraction(self):
self.assertEqual(simplify_fraction((1, 3)), (1, 3))
def test_check_the_simlify_fraction_function_with_true_answer(self):
self.assertEqual((3, 22), simplify_fraction((63, 462)))
