def testExceptions(self):
""" Test throwing exception. """
with self.assertRaises(BasesError):
Nats.convert_from_int(-32, 2)
with self.assertRaises(BasesError):
Nats.convert_from_int(32, -2)
with self.assertRaises(BasesError):
Nats.convert([1], 1, 2)
with self.assertRaises(BasesError):
Nats.convert([1], 2, 1)
with self.assertRaises(BasesError):
Nats.convert_to_int([1], 1)
with self.assertRaises(BasesError):
Nats.convert_to_int([-1], 2)
with self.assertRaises(BasesError):
Nats.carry_in([-1], 1, 2)
with self.assertRaises(BasesError):
Nats.carry_in([1], -1, 2)
with self.assertRaises(BasesError):
Nats.carry_in([1], 1, 1)
with self.assertRaises(BasesError):
Nats.roundTo([1], 0, 2, RoundingMethods.ROUND_DOWN)
with self.assertRaises(BasesError):
Nats.roundTo([3], 2, 2, RoundingMethods.ROUND_DOWN)
with self.assertRaises(BasesError):
Nats.roundTo([1], 2, 2, None)
def testFromInt(self, value, to_base):
"""
convert_to_int(convert_from_int(value, to_base), 10) == value
No leading zeros in convert_from_int(value, to_base)
"""
result = Nats.convert_from_int(value, to_base)
assert result[:1] != [0]
assert Nats.convert_to_int(result, to_base) == value
def test_from_int(self, value, to_base):
"""
convert_to_int(convert_from_int(value, to_base), 10) == value
No leading zeros in convert_from_int(value, to_base)
"""
result = Nats.convert_from_int(value, to_base)
self.assertNotEqual(result[:1], [0])
self.assertEqual(Nats.convert_to_int(result, to_base), value)
def test_exceptions(self):
"""Test throwing exception."""
with self.assertRaises(BasesError):
Nats.convert_from_int(-32, 2)
with self.assertRaises(BasesError):
Nats.convert_from_int(32, -2)
with self.assertRaises(BasesError):
Nats.convert([1], 1, 2)
with self.assertRaises(BasesError):
Nats.convert([1], 2, 1)
with self.assertRaises(BasesError):
Nats.convert_to_int([1], 1)
with self.assertRaises(BasesError):
Nats.convert_to_int([-1], 2)
with self.assertRaises(BasesError):
Nats.carry_in([-1], 1, 2)
with self.assertRaises(BasesError):
Nats.carry_in([1], -1, 2)
with self.assertRaises(BasesError):
Nats.carry_in([1], 1, 1)
def testCarryIn(self, strategy):
"""
Test carry_in.
:param strategy: the strategy (tuple of value, carry, base)
"""
(value, base, carry) = strategy
(carry_out, result) = Nats.carry_in(value, carry, base)
assert len(result) == len(value)
result2 = Nats.convert_from_int(
Nats.convert_to_int(value, base) + carry,
base
)
assert len(result2) >= len(result)
assert (len(result2) == len(result)) or \
result2[0] == carry_out and result2[1:] == result
assert not (len(result2) == len(result)) or result2 == result
def test_carry_in(self, strategy):
"""
Test carry_in.
:param strategy: the strategy (tuple of value, carry, base)
"""
(value, carry, base) = strategy
(carry_out, result) = Nats.carry_in(value, carry, base)
self.assertEqual(len(result), len(value))
result2 = Nats.convert_from_int(Nats.convert_to_int(value, base) + carry, base)
self.assertGreaterEqual(len(result2), len(result))
self.assertTrue(
(len(result2) == len(result))
or result2[0] == carry_out
and result2[1:] == result
)
self.assertTrue(not (len(result2) == len(result)) or result2 == result)
def test_up_down(self, divisor, dividend, base, precision):
"""
Test that rounding up and rounding down have the right relationship.
"""
# pylint: disable=too-many-locals
divisor = Nats.convert_from_int(divisor, base)
dividend = Nats.convert_from_int(dividend, base)
(integer_part, non_repeating_part, repeating_part,
rel) = NatDivision.division(divisor, dividend, base, precision,
RoundingMethods.ROUND_UP)
(
integer_part_2,
non_repeating_part_2,
repeating_part_2,
rel_2,
) = NatDivision.division(divisor, dividend, base, precision,
RoundingMethods.ROUND_DOWN)
(
integer_part_3,
non_repeating_part_3,
repeating_part_3,
rel_3,
) = NatDivision.division(divisor, dividend, base, precision,
RoundingMethods.ROUND_TO_ZERO)
self.assertEqual(integer_part_2, integer_part_3)
self.assertEqual(non_repeating_part_2, non_repeating_part_3)
self.assertEqual(repeating_part_2, repeating_part_3)
self.assertTrue(repeating_part != [] or repeating_part_2 == [])
self.assertGreaterEqual(rel, rel_2)
self.assertEqual(rel_2, rel_3)
round_up_int = Nats.convert_to_int(integer_part + non_repeating_part,
base)
round_down_int = Nats.convert_to_int(
integer_part_2 + non_repeating_part_2, base)
if repeating_part == []:
self.assertIn(round_up_int - round_down_int, (0, 1))
if rel == 0:
self.assertEqual(round_up_int, round_down_int)
self.assertEqual(rel_2, 0)
self.assertEqual(rel_3, 0)
for method in RoundingMethods.CONDITIONAL_METHODS():
(integer_part_c, non_repeating_part_c, _,
rel) = NatDivision.division(divisor, dividend, base, precision,
method)
rounded_int = Nats.convert_to_int(
integer_part_c + non_repeating_part_c, base)
if repeating_part == []:
self.assertLessEqual(round_down_int, rounded_int)
self.assertLessEqual(rounded_int, round_up_int)
if rel == 0:
self.assertEqual(round_up_int, round_down_int)
elif rel == -1:
self.assertEqual(rounded_int, round_down_int)
else:
self.assertEqual(rounded_int, round_up_int)
