def test_validate_denominator_is_not_zero(self):
#self.assertRaises(ValidationError,simplify_fraction,(1,2))
with self.assertRaises(CustomError) as exc:
simplify_fraction((1, 0))
#print(str(exc.exception))
self.assertTrue(
'you should use another denominator' in str(exc.exception))
def collect_fractions(fracts):
if not isinstance(fracts, list):
raise fractions.ValidationError('You should provide list of fractions')
else:
nominators = []
denominators = []
for fract in fracts:
simpl = fractions.simplify_fraction(fract)
nominators.append(simpl[0])
denominators.append(simpl[1])
lcm_of_denominators = reduce(lambda x, y: lcm(x, y), denominators)
for i in range(len(denominators)):
nominators[i] *= lcm_of_denominators / denominators[i]
denominators = [lcm_of_denominators] * (len(nominators))
sum_of_fractions = (sum(nominators), lcm_of_denominators)
return (fractions.simplify_fraction(sum_of_fractions))
def sort_fractions(fracts):
simplified = [fractions.simplify_fraction(x) for x in fracts]
answer = {}
for i in range(0, len(fracts)):
curr_fract = simplified[i]
key = curr_fract[0]/curr_fract[1]
print(key)
answer[key] = fracts[i]
for key in sorted(answer.keys()):
print(answer[key])
pass
def test_simplify_fraction_correct_input(self):
with self.assertRaises(TypeError):
simplify_fraction(('a', 1))
with self.assertRaises(TypeError):
simplify_fraction((1, 'a'))
with self.assertRaises(TypeError):
simplify_fraction(('a', 'a'))
def test_validate_fraction_object_is_a_tuple(self):
#self.assertRaises(ValidationError,simplify_fraction,(1,2))
with self.assertRaises(Exception) as exc:
simplify_fraction([1, 2])
#print(str(exc.exception))
self.assertTrue('not a tuple' in str(exc.exception))
def test_when_denominator_is_one_then_return__nominator_one(self):
tpl = (5, 1)
expected_result = (5, 1)
self.assertEqual(simplify_fraction(tpl), expected_result)
def test_simplify_tractions_if_nominator_and_denominator_do_not_have_gcd(
self):
input_fraction = (1, 7)
expected_result = (1, 7)
self.assertEqual(frac.simplify_fraction(input_fraction),
expected_result)
def test_when_prime_numbers_are_simplified_then_return_same(self):
test_data = (3, 17)
expected_Result = (3, 17)
self.assertEqual(fractions.simplify_fraction(test_data),
expected_Result)
def test_if_validate_fraction_object_is_not_a_tuple(self):
with self.assertRaises(fractions.ValidationError) as exc:
fractions.simplify_fraction([5, 5])
def test_basic_case_when_simplify_fraction_then_divide_both_by_biggest_common_divisor(
self):
test_data = (21, 7)
expected_result = (3, 1)
self.assertEqual(fractions.simplify_fraction(test_data),
expected_result)
def test_simplify_fraction():
assert simplify_fraction(2, 4) == (1, 2)
assert simplify_fraction(124, 4) == (31, 1)
assert simplify_fraction(1, 2) == (1, 2)
def test_simplify_fraction_zero_division(self):
with self.assertRaises(ZeroDivisionError):
simplify_fraction((1, 0))
def test_simplify_fraction_works(self):
self.assertEqual(simplify_fraction((3, 9)), (1, 3))
self.assertEqual(simplify_fraction((1, 7)), (1, 7))
self.assertEqual(simplify_fraction((4, 10)), (2, 5))
self.assertEqual(simplify_fraction((63, 462)), (3, 22))
def test_when_passed_arg_is_not_tuple(self):
expr = 1
with self.assertRaises(Exception) as exc:
simplify_fraction(expr)
def test_when_fraction_is_simplified_by_number_then_return_new_fractions(
self):
fraction = (17, 34)
expeted_result = (1, 2)
self.assertEqual(simplify_fraction(fraction), expeted_result)
def test_when_division_by_zero_then_raise_exception(self):
expr = (1, 0)
with self.assertRaises(Exception) as exc:
simplify_fraction(expr)
def test_when_nominator_and_denominator_are_equal_then_return_one_one(
self):
tpl = (5, 5)
expected_result = (1, 1)
self.assertEqual(simplify_fraction(tpl), expected_result)
def test_when_divider_is_zero(self):
test_data = (6, 0)
with self.assertRaises(ZeroDivisionError) as exc:
fractions.simplify_fraction(test_data)
