def test_pow_iin(self):
     x = 10
     y = 2
     f1 = wrapint(self.space, x)
     f2 = wrapint(self.space, y)
     v = self.space.pow(f1, f2, self.space.w_None)
     assert v.intval == x ** y

 def test_and(self):
     x = 12345678
     y = 2
     f1 = wrapint(self.space, x)
     f2 = wrapint(self.space, y)
     v = self.space.and_(f1, f2)
     assert v.intval == x & y

 def test_rshift(self):
     x = 12345678
     y = 2
     f1 = wrapint(self.space, x)
     f2 = wrapint(self.space, y)
     v = self.space.rshift(f1, f2)
     assert v.intval == x >> y

 def test_mul(self):
     for x in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - 1000]:
         for y in [0, 1, 100, sys.maxint // 2 - 50, sys.maxint - 1000]:
             f1 = wrapint(self.space, x)
             f2 = wrapint(self.space, y)
             result = self.space.unwrap(self.space.mul(f1, f2))
             assert result == x*y and type(result) == type(x*y)

 def test_or(self):
     x = 12345678
     y = 2
     f1 = wrapint(self.space, x)
     f2 = wrapint(self.space, y)
     v = self.space.or_(f1, f2)
     assert v.intval == x | y

 def test_div(self):
     for i in range(10):
         res = i//3
         f1 = wrapint(self.space, i)
         f2 = wrapint(self.space, 3)
         result = self.space.div(f1, f2)
         assert result.intval == res

 def test_mod(self):
     x = 1
     y = 2
     f1 = wrapint(self.space, x)
     f2 = wrapint(self.space, y)
     v = self.space.mod(f1, f2)
     assert v.intval == x % y

 def test_divmod(self):
     x = 1
     y = 2
     f1 = wrapint(self.space, x)
     f2 = wrapint(self.space, y)
     ret = self.space.divmod(f1, f2)
     v, w = self.space.unwrap(ret)
     assert (v, w) == divmod(x, y)

 def test_add(self):
     for x in [1, 100, sys.maxint // 2 - 50,
               sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
         for y in [1, 100, sys.maxint // 2 - 50,
                   sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
             f1 = wrapint(self.space, x)
             f2 = wrapint(self.space, y)
             result = self.space.unwrap(self.space.add(f1, f2))
             assert result == x+y

def len__RopeIter(space,  w_ropeiter):
    if w_ropeiter.node is None:
        return wrapint(space, 0)
    index = w_ropeiter.index
    length = w_ropeiter.node.length()
    result = length - index
    if result < 0:
        return wrapint(space, 0)
    return wrapint(space, result)

 def test_abs(self):
     x = 42
     f1 = wrapint(self.space, x)
     v = self.space.abs(f1)
     assert v.intval == abs(x)
     x = -42
     f1 = wrapint(self.space, x)
     v = self.space.abs(f1)
     assert v.intval == abs(x)

 def test_sub(self):
     for x in [1, 100, sys.maxint // 2 - 50,
               sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
         for y in [1, 100, sys.maxint // 2 - 50,
                   sys.maxint // 2, sys.maxint - 1000, sys.maxint]:
             f1 = wrapint(self.space, x)
             f2 = wrapint(self.space, y)
             result = self.space.unwrap(self.space.sub(f1, f2))
             assert result == x-y and type(result) == type(x-y)

def len__RangeIter(space,  w_rangeiter):
    if w_rangeiter.w_rangelist is None:
        return wrapint(space, 0)
    index = w_rangeiter.index
    w_length = space.len(w_rangeiter.w_rangelist)
    w_len = space.sub(w_length, wrapint(space, index))
    if space.is_true(space.lt(w_len, wrapint(space, 0))):
        w_len = wrapint(space, 0)
    return w_len

 def test_pos(self):
     x = 42
     f1 = wrapint(self.space, x)
     v = self.space.pos(f1)
     assert v.intval == +x
     x = -42
     f1 = wrapint(self.space, x)
     v = self.space.pos(f1)
     assert v.intval == +x

 def test_compare(self):
     import operator
     optab = ['lt', 'le', 'eq', 'ne', 'gt', 'ge']
     for x in (-10, -1, 0, 1, 2, 1000, sys.maxint):
         for y in (-sys.maxint-1, -11, -9, -2, 0, 1, 3, 1111, sys.maxint):
             for op in optab:
                 wx = wrapint(self.space, x)
                 wy = wrapint(self.space, y)
                 res = getattr(operator, op)(x, y)
                 method = getattr(self.space, op)
                 myres = method(wx, wy)
                 assert self.space.unwrap(myres) == res

def neg__Int(space, w_int1):
    a = w_int1.intval
    try:
        x = ovfcheck(-a)
    except OverflowError:
        raise FailedToImplement(space.w_OverflowError, space.wrap("integer negation"))
    return wrapint(space, x)

def str_rfind__Rope_Rope_ANY_ANY(space, w_self, w_sub, w_start, w_end):
    # XXX works but flattens
    (self, sub, start, end) =  _convert_idx_params(space, w_self, w_sub, w_start, w_end)
    self = self.flatten_string()
    sub = sub.flatten_string()
    res = self.rfind(sub, start, end)
    return wrapint(space, res)

def lshift__SmallInt_SmallInt(space, w_int1, w_int2):
    a = w_int1.intval
    b = w_int2.intval
    if b < 0:
        raise OperationError(space.w_ValueError,
                             space.wrap("negative shift count"))
    if a == 0 or b == 0:
        return int__SmallInt(space, w_int1)
    if b >= LONG_BIT:
        raise FailedToImplement(space.w_OverflowError,
                                space.wrap("integer left shift"))
    ##
    ## XXX please! have a look into pyport.h and see how to implement
    ## the overflow checking, using macro Py_ARITHMETIC_RIGHT_SHIFT
    ## we *assume* that the overflow checking is done correctly
    ## in the code generator, which is not trivial!
    
    ## XXX also note that Python 2.3 returns a long and never raises
    ##     OverflowError.
    try:
        c = ovfcheck_lshift(a, b)
        ## the test in C code is
        ## if (a != Py_ARITHMETIC_RIGHT_SHIFT(long, c, b)) {
        ##     if (PyErr_Warn(PyExc_FutureWarning,
        # and so on
    except OverflowError:
        raise FailedToImplement(space.w_OverflowError,
                                space.wrap("integer left shift"))
    return wrapint(space, c)

def _impl_int_int_pow(space, iv, iw, iz=0):
    if iw < 0:
        if iz != 0:
            raise OperationError(
                space.w_TypeError, space.wrap("pow() 2nd argument " "cannot be negative when 3rd argument specified")
            )
        ## bounce it, since it always returns float
        raise FailedToImplement(space.w_ValueError, space.wrap("integer exponentiation"))
    temp = iv
    ix = 1
    try:
        while iw > 0:
            if iw & 1:
                ix = ovfcheck(ix * temp)
            iw >>= 1  # /* Shift exponent down by 1 bit */
            if iw == 0:
                break
            temp = ovfcheck(temp * temp)  # /* Square the value of temp */
            if iz:
                # /* If we did a multiplication, perform a modulo */
                ix = ix % iz
                temp = temp % iz
        if iz:
            ix = ix % iz
    except OverflowError:
        raise FailedToImplement(space.w_OverflowError, space.wrap("integer exponentiation"))
    return wrapint(space, ix)

def sub__Int_Int(space, w_int1, w_int2):
    x = w_int1.intval
    y = w_int2.intval
    try:
        z = ovfcheck(x - y)
    except OverflowError:
        raise FailedToImplementArgs(space.w_OverflowError, space.wrap("integer substraction"))
    return wrapint(space, z)