def test_DivMod(self):
self.assertEqual(divmod(5000000000, 19),
divmod(gmp.Integer(5000000000), gmp.Integer(19)))
self.assertEqual(divmod(5000000000, 19),
divmod(gmp.Integer(5000000000), 19))
self.assertEqual(divmod(5000000000, 19),
divmod(5000000000, gmp.Integer(19)))
def test_And(self):
self.assertEqual(self.large_gmp & self.large_gmp, self.large_gmp)
self.assertEqual(self.large_gmp & self.small_gmp,
gmp.Integer(5000000000 & 19))
self.assertEqual(self.large_gmp & 250, gmp.Integer(5000000000 & 250))
self.assertEqual(self.large_neg_gmp & self.small_neg_gmp,
gmp.Integer(-5000000000 & -19))
def test_LargeMod(self):
self.assertEqual(self.large_gmp % self.small_gmp2,
gmp.Integer(5000000000 % 250))
self.assertEqual(self.large_gmp2 % self.large_gmp,
gmp.Integer(5000500500 % 5000000000))
self.assertEqual(self.large_gmp % self.small_gmp2 % self.small_gmp,
gmp.Integer(5000000000 % 250 % 19))
def test_LargeDivision(self):
self.assertEqual(self.large_gmp2 // self.large_gmp,
gmp.Integer(5000500500 // 5000000000))
self.assertEqual(self.large_gmp // self.small_gmp,
gmp.Integer(5000000000 // 19))
self.assertEqual(self.large_gmp // self.small_gmp // self.small_gmp,
gmp.Integer(5000000000 // 19 // 19))
def test_SimpleDivision(self):
self.assertEqual(self.small_gmp2 // self.small_gmp,
gmp.Integer(250 // 19))
self.assertEqual(self.small_gmp2 // self.small_gmp3,
gmp.Integer(250 // 50))
self.assertEqual(self.small_gmp // self.small_gmp2,
gmp.Integer(19 // 250))
def test_InPlaceAddition(self):
#Test_ in-place addition
i = self.small_gmp
i += self.small_gmp
self.assertEqual(i, gmp.Integer(199 + 199))
i += 5000000000
self.assertEqual(i, gmp.Integer(199 + 199 + 5000000000))
def test_Or(self):
self.assertEqual(self.large_gmp | gmp.Integer(), self.large_gmp)
self.assertEqual(gmp.Integer() | self.large_gmp, self.large_gmp)
self.assertEqual(self.large_gmp | self.small_gmp,
gmp.Integer(5000000000 | 19))
self.assertEqual(self.large_gmp | 250, gmp.Integer(5000000000 | 250))
self.assertEqual(self.large_neg_gmp | self.small_neg_gmp,
gmp.Integer(-5000000000 | -19))
def test_NegativeMod(self):
self.assertEqual(self.large_gmp % self.small_neg_gmp,
gmp.Integer(5000000000 % -19))
self.assertEqual(self.large_neg_gmp % self.small_neg_gmp,
gmp.Integer(-5000000000 % -19))
self.assertEqual(self.large_neg_gmp % self.small_gmp,
gmp.Integer(-5000000000 % 19))
self.assertEqual(self.large_gmp % -19, gmp.Integer(5000000000 % -19))
def test_NegativeDivision(self):
self.assertEqual(self.large_gmp // self.small_neg_gmp,
gmp.Integer(5000000000 // -19))
self.assertEqual(self.large_neg_gmp // self.small_neg_gmp,
gmp.Integer(-5000000000 // -19))
self.assertEqual(self.large_neg_gmp // self.small_gmp,
gmp.Integer(-5000000000 // 19))
self.assertEqual(self.large_neg_gmp // 50,
gmp.Integer(-5000000000 // 50))
self.assertEqual(self.large_gmp // -50, gmp.Integer(5000000000 // -50))
def test_LargeSubtraction(self):
self.assertEqual(self.large_gmp2 - self.large_gmp,
gmp.Integer(5000500500 - 5000000000))
self.assertEqual(self.large_gmp - self.large_gmp2,
gmp.Integer(5000000000 - 5000500500))
self.assertEqual(self.large_gmp - self.large_gmp - self.large_gmp,
self.large_neg_gmp)
self.assertEqual(
self.large_neg_gmp - self.large_neg_gmp - self.large_neg_gmp,
self.large_gmp)
def test_NegativeSubtraction(self):
self.assertEqual(self.small_neg_gmp2 - self.small_gmp,
gmp.Integer(-250 - 199))
self.assertEqual(self.small_neg_gmp2 - self.small_neg_gmp,
gmp.Integer(-250 - -199))
self.assertEqual(self.small_gmp2 - self.small_neg_gmp,
gmp.Integer(250 - -199))
self.assertEqual(self.large_gmp - -500000,
gmp.Integer(5000000000 - -500000))
self.assertEqual(-500000 - self.large_neg_gmp,
gmp.Integer(-500000 - -5000000000))
def setUp(self):
self.small_gmp = gmp.Integer(19)
self.small_gmp2 = gmp.Integer(250)
self.small_gmp3 = gmp.Integer(50)
self.large_gmp = gmp.Integer(5000000000)
self.large_gmp2 = gmp.Integer(5000500500)
self.small_neg_gmp = gmp.Integer(-19)
self.large_neg_gmp = gmp.Integer(-5000000000)
def test_DivisionBy0(self):
self.assertRaises(ZeroDivisionError, operator.floordiv, gmp.Integer(1),
gmp.Integer())
self.assertRaises(ZeroDivisionError, operator.floordiv, gmp.Integer(1),
0)
self.assertRaises(ZeroDivisionError, operator.floordiv, 1,
gmp.Integer())
self.assertRaises(ZeroDivisionError, operator.ifloordiv,
gmp.Integer(1), gmp.Integer())
self.assertRaises(ZeroDivisionError, operator.ifloordiv,
gmp.Integer(1), 0)
self.assertRaises(ZeroDivisionError, operator.ifloordiv, 1,
gmp.Integer())
def test_RealDivisionRaisesError(self):
self.assertRaises(NotImplementedError, operator.truediv,
gmp.Integer(1), 1)
self.assertRaises(NotImplementedError, operator.truediv,
gmp.Integer(1), gmp.Integer(1))
self.assertRaises(NotImplementedError, operator.truediv, 1,
gmp.Integer(1))
self.assertRaises(NotImplementedError, operator.itruediv,
gmp.Integer(1), 1)
self.assertRaises(NotImplementedError, operator.itruediv,
gmp.Integer(1), gmp.Integer(1))
self.assertRaises(NotImplementedError, operator.itruediv, 1,
gmp.Integer(1))
def test_Xor(self):
self.assertEqual(self.large_gmp ^ self.large_gmp, gmp.Integer())
self.assertEqual(self.large_gmp ^ gmp.Integer(), self.large_gmp)
self.assertEqual(gmp.Integer() ^ self.large_gmp, self.large_gmp)
self.assertEqual(self.large_gmp ^ self.small_gmp,
gmp.Integer(5000000000 ^ 19))
self.assertEqual(self.large_gmp ^ 250, gmp.Integer(5000000000 ^ 250))
self.assertEqual(self.large_neg_gmp ^ self.small_neg_gmp,
gmp.Integer(-5000000000 ^ -19))
def test_AdditionWithNegatives(self):
self.assertEqual(self.large_gmp + self.large_neg_gmp, gmp.Integer())
self.assertEqual(self.large_gmp + self.small_neg_gmp,
gmp.Integer(5000000000 + -199))
self.assertEqual(self.small_gmp + self.large_neg_gmp,
gmp.Integer(199 + -5000000000))
self.assertEqual(self.large_neg_gmp + self.large_neg_gmp,
gmp.Integer(-5000000000 + -5000000000))
self.assertEqual(self.large_gmp + -6000000000,
gmp.Integer(5000000000 + -6000000000))
self.assertEqual(6000000000 + self.large_neg_gmp,
gmp.Integer(6000000000 + -5000000000))
def test_PyLongReverseAddition(self):
self.assertEqual(150 + self.small_gmp, gmp.Integer(199 + 150))
self.assertEqual(150 + self.large_gmp, gmp.Integer(5000000000 + 150))
def test_LargeAddition(self):
self.assertEqual(self.large_gmp + self.large_gmp,
gmp.Integer(5000000000 + 5000000000))
self.assertEqual(self.large_gmp + self.large_gmp + self.large_gmp,
gmp.Integer(5000000000 * 3))
def test_PyLongAddition(self):
self.assertEqual(self.small_gmp + 150, gmp.Integer(199 + 150))
self.assertEqual(self.large_gmp + 150, gmp.Integer(5000000000 + 150))
def test_SetNegative(self):
self.inst.set(-5000000000)
self.assertEqual(self.inst, gmp.Integer(-5000000000))
self.inst.set(self.large_neg_gmp)
self.assertEqual(self.inst, self.large_neg_gmp)
def test_SimpleAddition(self):
self.assertEqual(self.small_gmp + self.small_gmp,
gmp.Integer(199 + 199))
def setUp(self):
self.large_gmp = gmp.Integer(5000000000)
self.large_gmp2 = gmp.Integer(50000000001)
def test_DivModBy0(self):
self.assertRaises(ZeroDivisionError, divmod, gmp.Integer(10), 0)
self.assertRaises(ZeroDivisionError, divmod, gmp.Integer(10),
gmp.Integer())
self.assertRaises(ZeroDivisionError, divmod, 10, gmp.Integer())
def setUp(self):
self.large_gmp = gmp.Integer(4294967300)
self.large_neg_gmp = gmp.Integer(-4294967300)
self.inst = gmp.Integer(10)
def test_ModBy0(self):
self.assertRaises(ZeroDivisionError, operator.mod, gmp.Integer(1),
gmp.Integer())
self.assertRaises(ZeroDivisionError, operator.mod, gmp.Integer(1), 0)
self.assertRaises(ZeroDivisionError, operator.mod, 1, gmp.Integer())
def test_Absolute(self):
self.assertEqual(abs(self.large_gmp), self.large_gmp)
self.assertEqual(abs(self.large_neg_gmp), self.large_gmp)
self.assertEqual(abs(gmp.Integer()), gmp.Integer())
def test_Negation(self):
self.assertEqual(-self.large_gmp, self.large_neg_gmp)
self.assertEqual(-self.large_neg_gmp, self.large_gmp)
self.assertEqual(-gmp.Integer(), gmp.Integer())
def test_SetPyLong(self):
self.inst.set(5000000000)
self.assertEqual(self.inst, gmp.Integer(5000000000))
def test_InPlaceXor(self):
i = self.large_gmp
i ^= self.small_gmp
self.assertEqual(i, gmp.Integer(5000000000 ^ 19))
i ^= 250
self.assertEqual(i, gmp.Integer(5000000000 ^ 19 ^ 250))
def test_InPlaceOr(self):
i = self.large_gmp
i |= self.small_gmp
self.assertEqual(i, gmp.Integer(5000000000 | 19))
i |= 250
self.assertEqual(i, gmp.Integer(5000000000 | 19 | 250))
