[pypy-svn] r33052 - pypy/branch/even-more-config2/pypy/translator/c/test

cfbolz at codespeak.net cfbolz at codespeak.net
Mon Oct 9 15:29:20 CEST 2006


Author: cfbolz
Date: Mon Oct  9 15:29:19 2006
New Revision: 33052

Modified:
   pypy/branch/even-more-config2/pypy/translator/c/test/test_backendoptimized.py
   pypy/branch/even-more-config2/pypy/translator/c/test/test_typed.py
Log:
clean up tests a bit: remove the default argument hack to specify types,
whitespace, delete a dead test


Modified: pypy/branch/even-more-config2/pypy/translator/c/test/test_backendoptimized.py
==============================================================================
--- pypy/branch/even-more-config2/pypy/translator/c/test/test_backendoptimized.py	(original)
+++ pypy/branch/even-more-config2/pypy/translator/c/test/test_backendoptimized.py	Mon Oct  9 15:29:19 2006
@@ -15,12 +15,12 @@
             t.view()
 
     def test_remove_same_as(self):
-        def f(n=bool):
+        def f(n):
             if bool(bool(bool(n))):
                 return 123
             else:
                 return 456
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [bool])
         assert f(True) == 123
         assert f(False) == 456
 
@@ -39,13 +39,13 @@
             def __del__(self):
                 b.num_deleted += 1
 
-        def f(x=int):
+        def f(x):
             a = A()
             for i in range(x):
                 a = A()
             return b.num_deleted
 
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int])
         res = f(5)
         assert res == 5
         res = fn(5)
@@ -66,7 +66,7 @@
                 s.b_dels += 1
         class C(A):
             pass
-        def f(x=int):
+        def f(x):
             A()
             B()
             C()
@@ -77,7 +77,7 @@
                 return s.a_dels * 10 + s.b_dels
             else:
                 return -1
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int])
         res = f(1)
         assert res == 42
         res = fn(1)
@@ -92,7 +92,7 @@
             backend_optimizations(t, merge_if_blocks_to_switch=True)
 
     def test_int_switch(self):
-        def f(x=int):
+        def f(x):
             if x == 3:
                 return 9
             elif x == 9:
@@ -101,12 +101,12 @@
                 return 3
             return 0
         codegenerator = self.CodeGenerator()
-        fn = codegenerator.getcompiled(f)
+        fn = codegenerator.getcompiled(f, [int])
         for x in (0,1,2,3,9,27,48, -9):
             assert fn(x) == f(x)
 
     def test_uint_switch(self):
-        def f(x=r_uint):
+        def f(x):
             if x == r_uint(3):
                 return 9
             elif x == r_uint(9):
@@ -115,12 +115,12 @@
                 return 3
             return 0
         codegenerator = self.CodeGenerator()
-        fn = codegenerator.getcompiled(f)
+        fn = codegenerator.getcompiled(f, [r_uint])
         for x in (0,1,2,3,9,27,48):
             assert fn(x) == f(x)
 
     def test_longlong_switch(self):
-        def f(x=r_longlong):
+        def f(x):
             if x == r_longlong(3):
                 return 9
             elif x == r_longlong(9):
@@ -129,12 +129,12 @@
                 return 3
             return 0
         codegenerator = self.CodeGenerator()
-        fn = codegenerator.getcompiled(f)
+        fn = codegenerator.getcompiled(f, [r_longlong])
         for x in (0,1,2,3,9,27,48, -9):
             assert fn(x) == f(x)
 
     def test_ulonglong_switch(self):
-        def f(x=r_ulonglong):
+        def f(x):
             if x == r_ulonglong(3):
                 return 9
             elif x == r_ulonglong(9):
@@ -143,12 +143,12 @@
                 return 3
             return 0
         codegenerator = self.CodeGenerator()
-        fn = codegenerator.getcompiled(f)
+        fn = codegenerator.getcompiled(f, [r_ulonglong])
         for x in (0,1,2,3,9,27,48, -9):
             assert fn(x) == f(x)
 
     def test_chr_switch(self):
-        def f(y=int):
+        def f(y):
             x = chr(y)
             if x == 'a':
                 return 'b'
@@ -158,13 +158,13 @@
                 return 'd'
             return '@'
         codegenerator = self.CodeGenerator()
-        fn = codegenerator.getcompiled(f)
+        fn = codegenerator.getcompiled(f, [int])
         for x in 'ABCabc@':
             y = ord(x)
             assert fn(y) == f(y)
 
     def test_unichr_switch(self):
-        def f(y=int):
+        def f(y):
             x = unichr(y)
             if x == u'a':
                 return 'b'
@@ -174,7 +174,7 @@
                 return 'd'
             return '@'
         codegenerator = self.CodeGenerator()
-        fn = codegenerator.getcompiled(f)
+        fn = codegenerator.getcompiled(f, [int])
         for x in u'ABCabc@':
             y = ord(x)
             assert fn(y) == f(y)
@@ -219,13 +219,13 @@
             backend_optimizations(t, raisingop2direct_call_all=True)
 
     def test_int_floordiv_zer(self):
-        def f(x=int):
+        def f(x):
             try:
                 y = 123 / x
             except:
                 y = 456
             return y
         codegenerator = self.CodeGenerator()
-        fn = codegenerator.getcompiled(f)
+        fn = codegenerator.getcompiled(f, [int])
         for x in (0,1,2,3,9,27,48, -9):
             assert fn(x) == f(x)

Modified: pypy/branch/even-more-config2/pypy/translator/c/test/test_typed.py
==============================================================================
--- pypy/branch/even-more-config2/pypy/translator/c/test/test_typed.py	(original)
+++ pypy/branch/even-more-config2/pypy/translator/c/test/test_typed.py	Mon Oct  9 15:29:19 2006
@@ -18,14 +18,7 @@
     def annotatefunc(self, func, argtypes=None):
         t = TranslationContext(simplifying=True)
         if argtypes is None:
-            # builds starting-types from func_defs
-            # XXX kill kill kill!
             argtypes = []
-            if func.func_defaults:
-                for spec in func.func_defaults:
-                    if isinstance(spec, tuple):
-                        spec = spec[0] # use the first type only for the tests
-                    argtypes.append(spec)
         a = t.buildannotator()
         a.build_types(func, argtypes)
         a.simplify()
@@ -65,15 +58,15 @@
         assert inheritance2() == ((-12, -12), (3, "world"))
 
     def test_factorial2(self):
-        factorial2 = self.getcompiled(snippet.factorial2)
+        factorial2 = self.getcompiled(snippet.factorial2, [int])
         assert factorial2(5) == 120
 
     def test_factorial(self):
-        factorial = self.getcompiled(snippet.factorial)
+        factorial = self.getcompiled(snippet.factorial, [int])
         assert factorial(5) == 120
 
     def test_simple_method(self):
-        simple_method = self.getcompiled(snippet.simple_method)
+        simple_method = self.getcompiled(snippet.simple_method, [int])
         assert simple_method(55) == 55
 
     def test_sieve_of_eratosthenes(self):
@@ -81,19 +74,16 @@
         assert sieve_of_eratosthenes() == 1028
 
     def test_nested_whiles(self):
-        nested_whiles = self.getcompiled(snippet.nested_whiles)
+        nested_whiles = self.getcompiled(snippet.nested_whiles, [int, int])
         assert nested_whiles(5,3) == '!!!!!'
 
     def test_call_five(self):
-        call_five = self.getcompiled(snippet.call_five)
+        call_five = self.getcompiled(snippet.call_five, [int])
         result = call_five()
         assert result == [5]
-        # --  currently result isn't a real list, but a pseudo-array
-        #     that can't be inspected from Python.
-        #self.assertEquals(result.__class__.__name__[:8], "list of ")
 
     def test_call_unpack_56(self):
-        call_unpack_56 = self.getcompiled(snippet.call_unpack_56)
+        call_unpack_56 = self.getcompiled(snippet.call_unpack_56, [])
         result = call_unpack_56()
         assert result == (2, 5, 6)
 
@@ -108,16 +98,16 @@
         assert fn() == "hello world"
 
     def test_tuple_repr(self):
-        def tuple_repr(x=int, y=object):
+        def tuple_repr(x, y):
             z = x, y
             while x:
                 x = x-1
             return z
-        fn = self.getcompiled(tuple_repr)
+        fn = self.getcompiled(tuple_repr, [int, str])
         assert fn(6,'a') == (6,'a')
 
     def test_classattribute(self):
-        fn = self.getcompiled(snippet.classattribute)
+        fn = self.getcompiled(snippet.classattribute, [int])
         assert fn(1) == 123
         assert fn(2) == 456
         assert fn(3) == 789
@@ -125,51 +115,41 @@
         assert fn(5) == 101112
 
     def test_get_set_del_slice(self):
-        fn = self.getcompiled(snippet.get_set_del_slice)
+        fn = self.getcompiled(snippet.get_set_del_slice, [list])
         l = list('abcdefghij')
         result = fn(l)
         assert l == [3, 'c', 8, 11, 'h', 9]
         assert result == ([3, 'c'], [9], [11, 'h'])
 
-    def test_slice_long(self):
-        def slice_long(l=list, n=long):
-            return l[:n]
-        fn = self.getcompiled(slice_long)
-        l = list('abc')
-        result = fn(l, 2**32)
-        assert result == list('abc')
-        result = fn(l, 2**64)
-        assert result == list('abc')
-
     def test_type_conversion(self):
         # obfuscated test case specially for typer.insert_link_conversions()
-        def type_conversion(n=int):
+        def type_conversion(n):
             if n > 3:
                 while n > 0:
                     n = n-1
                     if n == 5:
                         n += 3.1416
             return n
-        fn = self.getcompiled(type_conversion)
+        fn = self.getcompiled(type_conversion, [int])
         assert fn(3) == 3
         assert fn(5) == 0
         assert abs(fn(7) + 0.8584) < 1E-5
 
     def test_do_try_raise_choose(self):
-        fn = self.getcompiled(snippet.try_raise_choose)
+        fn = self.getcompiled(snippet.try_raise_choose, [int])
         result = []
         for n in [-1,0,1,2]:
             result.append(fn(n))
-        assert result == [-1,0,1,2]    
+        assert result == [-1,0,1,2]
 
     def test_is_perfect_number(self):
-        fn = self.getcompiled(snippet.is_perfect_number)
+        fn = self.getcompiled(snippet.is_perfect_number, [int])
         for i in range(1, 33):
             perfect = fn(i)
             assert perfect is (i in (6,28))
 
     def test_prime(self):
-        fn = self.getcompiled(snippet.prime)
+        fn = self.getcompiled(snippet.prime, [int])
         result = [fn(i) for i in range(1, 21)]
         assert result == [False, True, True, False, True, False, True, False,
                           False, False, True, False, True, False, False, False,
@@ -178,7 +158,7 @@
     def test_mutate_global(self):
         class Stuff:
             pass
-        g1 = Stuff(); g1.value = 1 
+        g1 = Stuff(); g1.value = 1
         g2 = Stuff(); g2.value = 2
         g3 = Stuff(); g3.value = 3
         g1.next = g3
@@ -193,88 +173,88 @@
         assert fn() == 1
 
     def test_float_ops(self):
-        def f(x=float):
+        def f(x):
             return abs((-x) ** 3 + 1)
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [float])
         assert fn(-4.5) == 92.125
         assert fn(4.5) == 90.125
 
     def test_memoryerror(self):
-        def f(i=int):
+        def f(i):
             lst = [0]*i
             lst[-1] = 5
             return lst[0]
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int])
         assert fn(1) == 5
         assert fn(2) == 0
         py.test.raises(MemoryError, fn, sys.maxint//2+1)
         py.test.raises(MemoryError, fn, sys.maxint)
 
     def test_chr(self):
-        def f(x=int):
+        def f(x):
             try:
                 return 'Yes ' + chr(x)
             except ValueError:
                 return 'No'
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int])
         assert fn(65) == 'Yes A'
         assert fn(256) == 'No'
         assert fn(-1) == 'No'
 
     def test_unichr(self):
-        def f(x=int):
+        def f(x):
             try:
                 return ord(unichr(x))
             except ValueError:
                 return -42
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int])
         assert fn(65) == 65
         assert fn(-12) == -42
         assert fn(sys.maxint) == -42
 
     def test_list_indexerror(self):
-        def f(i=int):
+        def f(i):
             lst = [123, 456]
             try:
                 lst[i] = 789
             except IndexError:
                 return 42
             return lst[0]
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int])
         assert fn(1) == 123
         assert fn(2) == 42
         assert fn(-2) == 789
         assert fn(-3) == 42
 
     def test_long_long(self):
-        def f(i=r_ulonglong):
+        def f(i):
             return 4*i
-        fn = self.getcompiled(f, view=False)
+        fn = self.getcompiled(f, [r_ulonglong], view=False)
         assert fn(sys.maxint) == 4*sys.maxint
 
-        def g(i=r_longlong):
+        def g(i):
             return 4*i
-        gn = self.getcompiled(g, view=False)
+        gn = self.getcompiled(g, [r_longlong], view=False)
         assert gn(sys.maxint) == 4*sys.maxint
 
     def test_specializing_int_functions(self):
         def f(i):
             return i + 1
         f._annspecialcase_ = "specialize:argtype(0)"
-        def g(n=int):
+        def g(n):
             if n > 0:
                 return f(r_longlong(0))
             else:
                 return f(0)
 
-        fn = self.getcompiled(g)
+        fn = self.getcompiled(g, [int])
         assert g(0) == 1
         assert g(1) == 1
 
     def test_downcast_int(self):
-        def f(i=r_longlong):
+        def f(i):
             return int(i)
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [r_longlong])
         assert fn(0) == 0
 
     def test_function_ptr(self):
@@ -282,13 +262,13 @@
             return 1
         def f2():
             return 2
-        def g(i=int):
+        def g(i):
             if i:
                 f = f1
             else:
                 f = f2
             return f()
-        fn = self.getcompiled(g)
+        fn = self.getcompiled(g, [int])
         assert fn(0) == 2
         assert fn(1) == 1
 
@@ -346,92 +326,92 @@
         assert result is False
 
     def test_str_compare(self):
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'twos', 'foobar']
             return s1[i] == s2[j]
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(2):
             for j in range(6):
                 res = fn(i, j)
                 assert res is testfn(i, j)
 
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'twos', 'foobar']
             return s1[i] != s2[j]
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(2):
             for j in range(6):
                 res = fn(i, j)
                 assert res is testfn(i, j)
                 
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'twos', 'foobar']
             return s1[i] < s2[j]
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(2):
             for j in range(6):
                 res = fn(i, j)
                 assert res is testfn(i, j)
                 
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'twos', 'foobar']
             return s1[i] <= s2[j]
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(2):
             for j in range(6):
                 res = fn(i, j)
                 assert res is testfn(i, j)
                 
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'twos', 'foobar']
             return s1[i] > s2[j]
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(2):
             for j in range(6):
                 res = fn(i, j)
                 assert res is testfn(i, j)
                 
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'twos', 'foobar']
             return s1[i] >= s2[j]
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(2):
             for j in range(6):
                 res = fn(i, j)
                 assert res is testfn(i, j)
                 
     def test_str_methods(self):
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'ne', 'e', 'twos', 'foobar', 'fortytwo']
-            return s1[i].startswith(s2[j])
+            return s1[i].startswith(s2[j], [int, int])
         fn = self.getcompiled(testfn)
         for i in range(2):
             for j in range(9):
                 res = fn(i, j)
                 assert res is testfn(i, j)
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = ['one', 'two']
             s2 = ['one', 'two', 'o', 'on', 'ne', 'e', 'twos', 'foobar', 'fortytwo']
             return s1[i].endswith(s2[j])
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(2):
             for j in range(9):
                 res = fn(i, j)
                 assert res is testfn(i, j)
 
     def test_str_join(self):
-        def testfn(i=int, j=int):
+        def testfn(i, j):
             s1 = [ '', ',', ' and ']
             s2 = [ [], ['foo'], ['bar', 'baz', 'bazz']]
             return s1[i].join(s2[j])
-        fn = self.getcompiled(testfn)
+        fn = self.getcompiled(testfn, [int, int])
         for i in range(3):
             for j in range(3):
                 res = fn(i, j)
@@ -439,9 +419,9 @@
     
     def test_unichr_eq(self):
         l = list(u'Hello world')
-        def f(i=int,j=int):
+        def f(i, j):
             return l[i] == l[j]
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int, int])
         for i in range(len(l)):
             for j in range(len(l)):
                 res = fn(i,j)
@@ -449,9 +429,9 @@
     
     def test_unichr_ne(self):
         l = list(u'Hello world')
-        def f(i=int,j=int):
+        def f(i, j):
             return l[i] != l[j]
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int, int])
         for i in range(len(l)):
             for j in range(len(l)):
                 res = fn(i,j)
@@ -459,37 +439,34 @@
 
     def test_unichr_ord(self):
         l = list(u'Hello world')
-        def f(i=int):
-            return ord(l[i]) 
-        fn = self.getcompiled(f)
+        def f(i):
+            return ord(l[i])
+        fn = self.getcompiled(f, [int])
         for i in range(len(l)):
             res = fn(i)
             assert res == f(i)
 
     def test_unichr_unichr(self):
         l = list(u'Hello world')
-        def f(i=int, j=int):
+        def f(i, j):
             return l[i] == unichr(j)
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int, int])
         for i in range(len(l)):
             for j in range(len(l)):
                 res = fn(i, ord(l[j]))
                 assert res == f(i, ord(l[j]))
 
-    def test_slice_long(self):
-        "the parent's test_slice_long() makes no sense here"
-
     def test_int_overflow(self):
-        fn = self.getcompiled(snippet.add_func)
+        fn = self.getcompiled(snippet.add_func, [int])
         raises(OverflowError, fn, sys.maxint)
 
     def test_int_floordiv_ovf_zer(self):
-        fn = self.getcompiled(snippet.div_func)
+        fn = self.getcompiled(snippet.div_func, [int])
         raises(OverflowError, fn, -1)
         raises(ZeroDivisionError, fn, 0)
 
     def test_int_mul_ovf(self):
-        fn = self.getcompiled(snippet.mul_func)
+        fn = self.getcompiled(snippet.mul_func, [int, int])
         for y in range(-5, 5):
             for x in range(-5, 5):
                 assert fn(x, y) == snippet.mul_func(x, y)
@@ -499,38 +476,38 @@
         raises(OverflowError, fn, n, 5)
 
     def test_int_mod_ovf_zer(self):
-        fn = self.getcompiled(snippet.mod_func)
+        fn = self.getcompiled(snippet.mod_func, [int])
         raises(OverflowError, fn, -1)
         raises(ZeroDivisionError, fn, 0)
 
     def test_int_rshift_val(self):
-        fn = self.getcompiled(snippet.rshift_func)
+        fn = self.getcompiled(snippet.rshift_func, [int])
         raises(ValueError, fn, -1)
 
     def test_int_lshift_ovf_val(self):
-        fn = self.getcompiled(snippet.lshift_func)
+        fn = self.getcompiled(snippet.lshift_func, [int])
         raises(ValueError, fn, -1)
         raises(OverflowError, fn, 1)
 
     def test_int_unary_ovf(self):
-        fn = self.getcompiled(snippet.unary_func)
+        fn = self.getcompiled(snippet.unary_func, [int])
         for i in range(-3,3):
             assert fn(i) == (-(i), abs(i-1))
         raises (OverflowError, fn, -sys.maxint-1)
         raises (OverflowError, fn, -sys.maxint)
 
     # floats 
-    def test_float_operations(self): 
+    def test_float_operations(self):
         import math
-        def func(x=float, y=float): 
-            z = x + y / 2.1 * x 
+        def func(x, y):
+            z = x + y / 2.1 * x
             z = math.fmod(z, 60.0)
             z = pow(z, 2)
             z = -z
-            return int(z) 
+            return int(z)
 
-        fn = self.getcompiled(func)
-        assert fn(5.0, 6.0) == func(5.0, 6.0) 
+        fn = self.getcompiled(func, [float, float])
+        assert fn(5.0, 6.0) == func(5.0, 6.0)
 
     def test_rpbc_bound_method_static_call(self):
         class R:
@@ -555,39 +532,39 @@
 
 
     def test_stringformatting(self):
-        def fn(i=int):
+        def fn(i):
             return "you said %d, you did"%i
-        f = self.getcompiled(fn)
+        f = self.getcompiled(fn, [int])
         assert f(1) == fn(1)
 
     def test_int2str(self):
-        def fn(i=int):
+        def fn(i):
             return str(i)
-        f = self.getcompiled(fn)
+        f = self.getcompiled(fn, [int])
         assert f(1) == fn(1)
 
     def test_float2str(self):
-        def fn(i=float):
+        def fn(i):
             return str(i)
-        f = self.getcompiled(fn)
+        f = self.getcompiled(fn, [float])
         res = f(1.0)
         assert type(res) is str and float(res) == 1.0
         
     def test_uint_arith(self):
-        def fn(i=r_uint):
+        def fn(i):
             try:
                 return ~(i*(i+1))/(i-1)
             except ZeroDivisionError:
                 return r_uint(91872331)
-        f = self.getcompiled(fn)
+        f = self.getcompiled(fn, [r_uint])
         for value in range(15):
             i = r_uint(value)
             assert f(i) == fn(i)
 
     def test_ord_returns_a_positive(self):
-        def fn(i=int):
+        def fn(i):
             return ord(chr(i))
-        f = self.getcompiled(fn)
+        f = self.getcompiled(fn, [int])
         assert f(255) == 255
 
     def test_hash_preservation(self):
@@ -613,7 +590,7 @@
         assert res[1] == intmask(hash(c)+hash(d))
 
     def test_list_basic_ops(self):
-        def list_basic_ops(i=int, j=int):
+        def list_basic_ops(i, j):
             l = [1,2,3]
             l.insert(0, 42)
             del l[1]
@@ -624,7 +601,7 @@
             l += [5,6] 
             l[1] = i
             return l[j]
-        f = self.getcompiled(list_basic_ops)
+        f = self.getcompiled(list_basic_ops, [int, int])
         for i in range(6): 
             for j in range(6): 
                 assert f(i,j) == list_basic_ops(i,j)
@@ -638,28 +615,28 @@
         assert f() == fn()
 
     def test_range_idx(self):
-        def fn(idx=int):
+        def fn(idx):
             r = range(10, 37, 4)
             try:
                 return r[idx]
             except: raise
-        f = self.getcompiled(fn)
+        f = self.getcompiled(fn, [int])
         assert f(0) == fn(0)
         assert f(-1) == fn(-1)
         raises(IndexError, f, 42)
 
     def test_range_step(self):
-        def fn(step=int):
+        def fn(step):
             r = range(10, 37, step)
             # we always raise on step = 0
             return r[-2]
-        f = self.getcompiled(fn)#, view=True)
+        f = self.getcompiled(fn, [int])
         assert f(1) == fn(1)
         assert f(3) == fn(3)
         raises(ValueError, f, 0)
 
     def test_range_iter(self):
-        def fn(start=int, stop=int, step=int):
+        def fn(start, stop, step):
             res = 0
             if step == 0:
                 if stop >= start:
@@ -671,17 +648,17 @@
             for i in r:
                 res = res * 51 + i
             return res
-        f = self.getcompiled(fn)
+        f = self.getcompiled(fn, [int, int, int])
         for args in [2, 7, 0], [7, 2, 0], [10, 50, 7], [50, -10, -3]:
             assert f(*args) == intmask(fn(*args))
 
     def test_recursion_detection(self):
-        def f(n=int, accum=int):
+        def f(n, accum):
             if n == 0:
                 return accum
             else:
                 return f(n-1, accum*n)
-        fn = self.getcompiled(f)
+        fn = self.getcompiled(f, [int, int])
         assert fn(7, 1) == 5040
         assert fn(7, 1) == 5040    # detection must work several times, too
         assert fn(7, 1) == 5040
@@ -719,13 +696,13 @@
             if x:
                 return f(x)
             return 1
-        def g(x=int):
+        def g(x):
             try:
                 f(x)
             except RuntimeError:
                 return 42
             return 1
-        fn = self.getcompiled(g)
+        fn = self.getcompiled(g, [int])
         assert fn(0) == 1
         assert fn(1) == 42
 
@@ -746,7 +723,7 @@
             except Exception:
                 return 42
             return x
-        fn = self.getcompiled(f)    
+        fn = self.getcompiled(f)
         res = fn()
         assert res == 42
 
@@ -758,9 +735,9 @@
             except TypeError:
                 return 42
             return x
-        fn = self.getcompiled(f)    
+        fn = self.getcompiled(f)
         res = fn()
-        assert res == 42    
+        assert res == 42
 
         def f():
             d1 = r_dict(eq, raising_hash)
@@ -770,6 +747,6 @@
             except TypeError:
                 return 42
             return 0
-        fn = self.getcompiled(f)    
+        fn = self.getcompiled(f)
         res = fn()
-        assert res == 42    
+        assert res == 42



More information about the Pypy-commit mailing list