def test_parse_digit_string(self):
     from pypy.rlib.rbigint import parse_digit_string
     class Parser:
         def __init__(self, base, sign, digits):
             self.base = base
             self.sign = sign
             self.next_digit = iter(digits + [-1]).next
     x = parse_digit_string(Parser(10, 1, [6]))
     assert x.eq(rbigint.fromint(6))
     x = parse_digit_string(Parser(10, 1, [6, 2, 3]))
     assert x.eq(rbigint.fromint(623))
     x = parse_digit_string(Parser(10, -1, [6, 2, 3]))
     assert x.eq(rbigint.fromint(-623))
     x = parse_digit_string(Parser(16, 1, [0xA, 0x4, 0xF]))
     assert x.eq(rbigint.fromint(0xA4F))
     num = 0
     for i in range(36):
         x = parse_digit_string(Parser(36, 1, range(i)))
         assert x.eq(rbigint.fromlong(num))
         num = num * 36 + i
     x = parse_digit_string(Parser(16, -1, range(15,-1,-1)*99))
     assert x.eq(rbigint.fromlong(long('-0x' + 'FEDCBA9876543210'*99, 16)))
     assert x.tobool() is True
     x = parse_digit_string(Parser(7, 1, [0, 0, 0]))
     assert x.tobool() is False
     x = parse_digit_string(Parser(7, -1, [0, 0, 0]))
     assert x.tobool() is False

 def test_order(self):
     f6 = rbigint.fromint(6)
     f7 = rbigint.fromint(7)
     assert (f6.lt(f6), f6.lt(f7), f7.lt(f6)) == (0,1,0)
     assert (f6.le(f6), f6.le(f7), f7.le(f6)) == (1,1,0)
     assert (f6.gt(f6), f6.gt(f7), f7.gt(f6)) == (0,0,1)
     assert (f6.ge(f6), f6.ge(f7), f7.ge(f6)) == (1,0,1)

 def test_uintmask(self):
     assert rbigint.fromint(-1).uintmask() == r_uint(-1)
     assert rbigint.fromint(0).uintmask() == r_uint(0)
     assert (rbigint.fromint(sys.maxint).uintmask() ==
             r_uint(sys.maxint))
     assert (rbigint.fromlong(sys.maxint+1).uintmask() ==
             r_uint(-sys.maxint-1))

 def test_floordiv(self):
     for op1 in [-12, -2, -1, 1, 2, 50]:
         for op2 in [-4, -2, -1, 1, 2, 8]:
             rl_op1 = rbigint.fromint(op1)
             rl_op2 = rbigint.fromint(op2)
             r1 = rl_op1.floordiv(rl_op2)
             r2 = op1 // op2
             assert r1.tolong() == r2

 def test_truediv(self):
     for op1 in [-12, -2, -1, 1, 2, 50]:
         for op2 in [-4, -2, -1, 1, 2, 8]:
             rl_op1 = rbigint.fromint(op1)
             rl_op2 = rbigint.fromint(op2)
             r1 = rl_op1.truediv(rl_op2)
             r2 = op1 / op2
             assert r1 == r2

 def test_pow(self):
     for op1 in [-50, -12, -2, -1, 1, 2, 50, 52]:
         for op2 in [0, 1, 2, 8, 9, 10, 11]:
             rl_op1 = rbigint.fromint(op1)
             rl_op2 = rbigint.fromint(op2)
             r1 = rl_op1.pow(rl_op2)
             r2 = op1 ** op2
             assert r1.tolong() == r2

 def test_mod(self):
     for op1 in [-50, -12, -2, -1, 1, 2, 50, 52]:
         for op2 in [-4, -2, -1, 1, 2, 8]:
             rl_op1 = rbigint.fromint(op1)
             rl_op2 = rbigint.fromint(op2)
             r1 = rl_op1.mod(rl_op2)
             r2 = op1 % op2
             assert r1.tolong() == r2

 def test_simple(self):
     for op1 in [-2, -1, 0, 1, 2, 50]:
         for op2 in [-2, -1, 0, 1, 2, 50]:
             rl_op1 = rbigint.fromint(op1)
             rl_op2 = rbigint.fromint(op2)
             for op in "add sub mul".split():
                 r1 = getattr(rl_op1, op)(rl_op2)
                 r2 = getattr(operator, op)(op1, op2)
                 assert r1.tolong() == r2

 def test_add(self):
     x = rbigint.fromint(-2147483647)
     y = rbigint.fromint(-1)
     z = rbigint.fromint(-2147483648)
     def test():
         return x.add(y).eq(z)
     assert test()
     res = interpret(test, [])
     assert res

 def test_bigint_w(self):
     space = self.space
     fromlong = lobj.W_LongObject.fromlong
     assert isinstance(space.bigint_w(fromlong(42)), rbigint)
     assert space.bigint_w(fromlong(42)).eq(rbigint.fromint(42))
     assert space.bigint_w(fromlong(-1)).eq(rbigint.fromint(-1))
     w_obj = space.wrap("hello world")
     space.raises_w(space.w_TypeError, space.bigint_w, w_obj)
     w_obj = space.wrap(123.456)
     space.raises_w(space.w_TypeError, space.bigint_w, w_obj)

def test_bigint_w():
    space = CPyObjSpace()
    r1 = space.bigint_w(space.newlong(42))
    assert isinstance(r1, rbigint)
    assert r1.eq(rbigint.fromint(42))
    # cpython digit size
    assert space.bigint_w(space.newlong(2**8)).eq(rbigint.fromint(2**8))
    # rpython digit size
    assert space.bigint_w(space.newlong(2**15)).eq(rbigint.fromint(2**15))
    # and negative numbers
    assert space.bigint_w(space.newlong(-1)).eq(rbigint.fromint(-1))
    assert space.bigint_w(space.newlong(-2**8)).eq(rbigint.fromint(-2**8))
    assert space.bigint_w(space.newlong(-2**15)).eq(rbigint.fromlong(-2**15))

def _PyLong_FromByteArray(space, bytes, n, little_endian, signed):
    little_endian = rffi.cast(lltype.Signed, little_endian)
    signed = rffi.cast(lltype.Signed, signed)

    result = rbigint()
    negative = False

    for i in range(0, n):
        if little_endian:
            c = intmask(bytes[i])
        else:
            c = intmask(bytes[n - i - 1])
        if i == 0 and signed and c & 0x80:
            negative = True
        if negative:
            c = c ^ 0xFF
        digit = rbigint.fromint(c)

        result = result.lshift(8)
        result = result.add(digit)

    if negative:
        result = result.neg()

    return space.newlong_from_rbigint(result)

 def immutable_unique_id(self, space):
     if self.user_overridden_class:
         return None
     from pypy.objspace.std.model import IDTAG_LONG as tag
     b = space.bigint_w(self)
     b = b.lshift(3).or_(rbigint.fromint(tag))
     return space.newlong_from_rbigint(b)

def pow__Long_Long_None(space, w_long1, w_long2, w_long3):
    # XXX need to replicate some of the logic, to get the errors right
    if w_long2.num.lt(rbigint.fromint(0)):
        raise FailedToImplementArgs(
            space.w_ValueError,
            space.wrap("long pow() too negative"))
    return W_LongObject(w_long1.num.pow(w_long2.num, None))

	def imod( self, other ):
		if self.bvalue:
			if other.bvalue:
				return HybridCell( 0, self.bvalue.mod( other.bvalue ) )
			else:
				o = rbigint.fromint(other.ivalue)
				v = self.bvalue.mod( o )
				return HybridCell( 0, v )
		else:
			if other.bvalue:
				s = rbigint.fromint(self.ivalue)
				v = s.mod( other.bvalue )
				return HybridCell( 0, v )
			else:
				v = self.ivalue % other.ivalue
				return HybridCell( v )

 def unique_id(self, space):
     if self.user_overridden_class:
         return W_Object.unique_id(self, space)
     from pypy.objspace.std.model import IDTAG_INT as tag
     b = space.bigint_w(self)
     b = b.lshift(3).or_(rbigint.fromint(tag))
     return space.newlong_from_rbigint(b)

    def test_conversions(self):
        for v in (0, 1, -1, sys.maxint, -sys.maxint-1):
            assert rbigint.fromlong(long(v)).tolong() == long(v)
            l = rbigint.fromint(v)
            assert l.toint() == v
            if v >= 0:
                u = l.touint()
                assert u == v
                assert type(u) is r_uint
            else:
                py.test.raises(ValueError, l.touint)

        toobig_lv1 = rbigint.fromlong(sys.maxint+1)
        assert toobig_lv1.tolong() == sys.maxint+1
        toobig_lv2 = rbigint.fromlong(sys.maxint+2)
        assert toobig_lv2.tolong() == sys.maxint+2
        toobig_lv3 = rbigint.fromlong(-sys.maxint-2)
        assert toobig_lv3.tolong() == -sys.maxint-2

        for lv in (toobig_lv1, toobig_lv2, toobig_lv3):
            py.test.raises(OverflowError, lv.toint)

        lmaxuint = rbigint.fromlong(2*sys.maxint+1)
        toobig_lv4 = rbigint.fromlong(2*sys.maxint+2)

        u = lmaxuint.touint()
        assert u == 2*sys.maxint+1

        py.test.raises(ValueError, toobig_lv3.touint)
        py.test.raises(OverflowError, toobig_lv4.touint)

 def test_hash(self):
     for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
               sys.maxint-3, sys.maxint-2, sys.maxint-1, sys.maxint,
               ] + [randint(0, sys.maxint) for _ in range(100)]:
         # hash of machine-sized integers
         assert rbigint.fromint(i).hash() == i
         # hash of negative machine-sized integers
         assert rbigint.fromint(-i-1).hash() == -i-1
     #
     for i in range(200):
         # hash of large integers: should be equal to the hash of the
         # integer reduced modulo 2**64-1, to make decimal.py happy
         x = randint(0, sys.maxint**5)
         y = x % (2**64-1)
         assert rbigint.fromlong(x).hash() == rbigint.fromlong(y).hash()
         assert rbigint.fromlong(-x).hash() == rbigint.fromlong(-y).hash()

 def unique_id(self, space):
     if self.user_overridden_class:
         return W_Object.unique_id(self, space)
     from pypy.rlib.longlong2float import float2longlong
     from pypy.objspace.std.model import IDTAG_FLOAT as tag
     val = float2longlong(space.float_w(self))
     b = rbigint.fromrarith_int(val)
     b = b.lshift(3).or_(rbigint.fromint(tag))
     return space.newlong_from_rbigint(b)

 def f(space, w_int1, w_float2):
     f2 = w_float2.floatval
     i1 = w_int1.intval
     f1 = float(i1)
     if LONG_BIT > 32 and int(f1) != i1:
         res = revcompare(f2, rbigint.fromint(i1))
     else:
         res = op(f1, f2)
     return space.newbool(res)