Lib/test/test_extcall.py

   1 from test.test_support import verify, verbose, TestFailed, sortdict
   2 from UserList import UserList
   3
   4 def f(*a, **k):
   5     print a, sortdict(k)
   6
   7 def g(x, *y, **z):
   8     print x, y, sortdict(z)
   9
  10 def h(j=1, a=2, h=3):
  11     print j, a, h
  12
  13 f()
  14 f(1)
  15 f(1, 2)
  16 f(1, 2, 3)
  17
  18 f(1, 2, 3, *(4, 5))
  19 f(1, 2, 3, *[4, 5])
  20 f(1, 2, 3, *UserList([4, 5]))
  21 f(1, 2, 3, **{'a':4, 'b':5})
  22 f(1, 2, 3, *(4, 5), **{'a':6, 'b':7})
  23 f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b':9})
  24
  25 try:
  26     g()
  27 except TypeError, err:
  28     print "TypeError:", err
  29 else:
  30     print "should raise TypeError: not enough arguments; expected 1, got 0"
  31
  32 try:
  33     g(*())
  34 except TypeError, err:
  35     print "TypeError:", err
  36 else:
  37     print "should raise TypeError: not enough arguments; expected 1, got 0"
  38
  39 try:
  40     g(*(), **{})
  41 except TypeError, err:
  42     print "TypeError:", err
  43 else:
  44     print "should raise TypeError: not enough arguments; expected 1, got 0"
  45
  46 g(1)
  47 g(1, 2)
  48 g(1, 2, 3)
  49 g(1, 2, 3, *(4, 5))
  50 class Nothing: pass
  51 try:
  52     g(*Nothing())
  53 except TypeError, attr:
  54     pass
  55 else:
  56     print "should raise TypeError"
  57
  58 class Nothing:
  59     def __len__(self):
  60         return 5
  61 try:
  62     g(*Nothing())
  63 except TypeError, attr:
  64     pass
  65 else:
  66     print "should raise TypeError"
  67
  68 class Nothing:
  69     def __len__(self):
  70         return 5
  71     def __getitem__(self, i):
  72         if i < 3:
  73             return i
  74         else:
  75             raise IndexError, i
  76 g(*Nothing())
  77
  78 # make sure the function call doesn't stomp on the dictionary?
  79 d = {'a': 1, 'b': 2, 'c': 3}
  80 d2 = d.copy()
  81 verify(d == d2)
  82 g(1, d=4, **d)
  83 print sortdict(d)
  84 print sortdict(d2)
  85 verify(d == d2, "function call modified dictionary")
  86
  87 # what about willful misconduct?
  88 def saboteur(**kw):
  89     kw['x'] = locals() # yields a cyclic kw
  90     return kw
  91 d = {}
  92 kw = saboteur(a=1, **d)
  93 verify(d == {})
  94 # break the cycle
  95 del kw['x']
  96
  97 try:
  98     g(1, 2, 3, **{'x':4, 'y':5})
  99 except TypeError, err:
 100     print err
 101 else:
 102     print "should raise TypeError: keyword parameter redefined"
 103
 104 try:
 105     g(1, 2, 3, a=4, b=5, *(6, 7), **{'a':8, 'b':9})
 106 except TypeError, err:
 107     print err
 108 else:
 109     print "should raise TypeError: keyword parameter redefined"
 110
 111 try:
 112     f(**{1:2})
 113 except TypeError, err:
 114     print err
 115 else:
 116     print "should raise TypeError: keywords must be strings"
 117
 118 try:
 119     h(**{'e': 2})
 120 except TypeError, err:
 121     print err
 122 else:
 123     print "should raise TypeError: unexpected keyword argument: e"
 124
 125 try:
 126     h(*h)
 127 except TypeError, err:
 128     print err
 129 else:
 130     print "should raise TypeError: * argument must be a tuple"
 131
 132 try:
 133     dir(*h)
 134 except TypeError, err:
 135     print err
 136 else:
 137     print "should raise TypeError: * argument must be a tuple"
 138
 139 try:
 140     None(*h)
 141 except TypeError, err:
 142     print err
 143 else:
 144     print "should raise TypeError: * argument must be a tuple"
 145
 146 try:
 147     h(**h)
 148 except TypeError, err:
 149     print err
 150 else:
 151     print "should raise TypeError: ** argument must be a dictionary"
 152
 153 try:
 154     dir(**h)
 155 except TypeError, err:
 156     print err
 157 else:
 158     print "should raise TypeError: ** argument must be a dictionary"
 159
 160 try:
 161     None(**h)
 162 except TypeError, err:
 163     print err
 164 else:
 165     print "should raise TypeError: ** argument must be a dictionary"
 166
 167 try:
 168     dir(b=1,**{'b':1})
 169 except TypeError, err:
 170     print err
 171 else:
 172     print "should raise TypeError: dir() got multiple values for keyword argument 'b'"
 173
 174 def f2(*a, **b):
 175     return a, b
 176
 177 d = {}
 178 for i in range(512):
 179     key = 'k%d' % i
 180     d[key] = i
 181 a, b = f2(1, *(2, 3), **d)
 182 print len(a), len(b), b == d
 183
 184 class Foo:
 185     def method(self, arg1, arg2):
 186         return arg1 + arg2
 187
 188 x = Foo()
 189 print Foo.method(*(x, 1, 2))
 190 print Foo.method(x, *(1, 2))
 191 try:
 192     print Foo.method(*(1, 2, 3))
 193 except TypeError, err:
 194     pass
 195 else:
 196     print 'expected a TypeError for unbound method call'
 197 try:
 198     print Foo.method(1, *(2, 3))
 199 except TypeError, err:
 200     pass
 201 else:
 202     print 'expected a TypeError for unbound method call'
 203
 204 # A PyCFunction that takes only positional parameters should allow an
 205 # empty keyword dictionary to pass without a complaint, but raise a
 206 # TypeError if the dictionary is non-empty.
 207 id(1, **{})
 208 try:
 209     id(1, **{"foo": 1})
 210 except TypeError:
 211     pass
 212 else:
 213     raise TestFailed, 'expected TypeError; no exception raised'
 214
 215 a, b, d, e, v, k = 'A', 'B', 'D', 'E', 'V', 'K'
 216 funcs = []
 217 maxargs = {}
 218 for args in ['', 'a', 'ab']:
 219     for defargs in ['', 'd', 'de']:
 220         for vararg in ['', 'v']:
 221             for kwarg in ['', 'k']:
 222                 name = 'z' + args + defargs + vararg + kwarg
 223                 arglist = list(args) + map(
 224                     lambda x: '%s="%s"' % (x, x), defargs)
 225                 if vararg: arglist.append('*' + vararg)
 226                 if kwarg: arglist.append('**' + kwarg)
 227                 decl = (('def %s(%s): print "ok %s", a, b, d, e, v, ' +
 228                          'type(k) is type ("") and k or sortdict(k)')
 229                          % (name, ', '.join(arglist), name))
 230                 exec(decl)
 231                 func = eval(name)
 232                 funcs.append(func)
 233                 maxargs[func] = len(args + defargs)
 234
 235 for name in ['za', 'zade', 'zabk', 'zabdv', 'zabdevk']:
 236     func = eval(name)
 237     for args in [(), (1, 2), (1, 2, 3, 4, 5)]:
 238         for kwargs in ['', 'a', 'd', 'ad', 'abde']:
 239             kwdict = {}
 240             for k in kwargs: kwdict[k] = k + k
 241             print func.func_name, args, sortdict(kwdict), '->',
 242             try: func(*args, **kwdict)
 243             except TypeError, err: print err