Lib/test/test_extcall.py

   1 """Doctest for method/function calls.
   2
   3 We're going the use these types for extra testing
   4
   5     >>> from collections import UserList
   6     >>> from collections import UserDict
   7
   8 We're defining four helper functions
   9
  10     >>> def e(a,b):
  11     ...     print(a, b)
  12
  13     >>> def f(*a, **k):
  14     ...     print(a, support.sortdict(k))
  15
  16     >>> def g(x, *y, **z):
  17     ...     print(x, y, support.sortdict(z))
  18
  19     >>> def h(j=1, a=2, h=3):
  20     ...     print(j, a, h)
  21
  22 Argument list examples
  23
  24     >>> f()
  25     () {}
  26     >>> f(1)
  27     (1,) {}
  28     >>> f(1, 2)
  29     (1, 2) {}
  30     >>> f(1, 2, 3)
  31     (1, 2, 3) {}
  32     >>> f(1, 2, 3, *(4, 5))
  33     (1, 2, 3, 4, 5) {}
  34     >>> f(1, 2, 3, *[4, 5])
  35     (1, 2, 3, 4, 5) {}
  36     >>> f(1, 2, 3, *UserList([4, 5]))
  37     (1, 2, 3, 4, 5) {}
  38
  39 Here we add keyword arguments
  40
  41     >>> f(1, 2, 3, **{'a':4, 'b':5})
  42     (1, 2, 3) {'a': 4, 'b': 5}
  43     >>> f(1, 2, 3, *[4, 5], **{'a':6, 'b':7})
  44     (1, 2, 3, 4, 5) {'a': 6, 'b': 7}
  45     >>> f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b': 9})
  46     (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
  47
  48     >>> f(1, 2, 3, **UserDict(a=4, b=5))
  49     (1, 2, 3) {'a': 4, 'b': 5}
  50     >>> f(1, 2, 3, *(4, 5), **UserDict(a=6, b=7))
  51     (1, 2, 3, 4, 5) {'a': 6, 'b': 7}
  52     >>> f(1, 2, 3, x=4, y=5, *(6, 7), **UserDict(a=8, b=9))
  53     (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
  54
  55 Examples with invalid arguments (TypeErrors). We're also testing the function
  56 names in the exception messages.
  57
  58 Verify clearing of SF bug #733667
  59
  60     >>> e(c=4)
  61     Traceback (most recent call last):
  62       ...
  63     TypeError: e() got an unexpected keyword argument 'c'
  64
  65     >>> g()
  66     Traceback (most recent call last):
  67       ...
  68     TypeError: g() takes at least 1 positional argument (0 given)
  69
  70     >>> g(*())
  71     Traceback (most recent call last):
  72       ...
  73     TypeError: g() takes at least 1 positional argument (0 given)
  74
  75     >>> g(*(), **{})
  76     Traceback (most recent call last):
  77       ...
  78     TypeError: g() takes at least 1 positional argument (0 given)
  79
  80     >>> g(1)
  81     1 () {}
  82     >>> g(1, 2)
  83     1 (2,) {}
  84     >>> g(1, 2, 3)
  85     1 (2, 3) {}
  86     >>> g(1, 2, 3, *(4, 5))
  87     1 (2, 3, 4, 5) {}
  88
  89     >>> class Nothing: pass
  90     ...
  91     >>> g(*Nothing())
  92     Traceback (most recent call last):
  93       ...
  94     TypeError: g() argument after * must be a sequence, not Nothing
  95
  96     >>> class Nothing:
  97     ...     def __len__(self): return 5
  98     ...
  99
 100     >>> g(*Nothing())
 101     Traceback (most recent call last):
 102       ...
 103     TypeError: g() argument after * must be a sequence, not Nothing
 104
 105     >>> class Nothing():
 106     ...     def __len__(self): return 5
 107     ...     def __getitem__(self, i):
 108     ...         if i<3: return i
 109     ...         else: raise IndexError(i)
 110     ...
 111
 112     >>> g(*Nothing())
 113     0 (1, 2) {}
 114
 115     >>> class Nothing:
 116     ...     def __init__(self): self.c = 0
 117     ...     def __iter__(self): return self
 118     ...     def __next__(self):
 119     ...         if self.c == 4:
 120     ...             raise StopIteration
 121     ...         c = self.c
 122     ...         self.c += 1
 123     ...         return c
 124     ...
 125
 126     >>> g(*Nothing())
 127     0 (1, 2, 3) {}
 128
 129 Make sure that the function doesn't stomp the dictionary
 130
 131     >>> d = {'a': 1, 'b': 2, 'c': 3}
 132     >>> d2 = d.copy()
 133     >>> g(1, d=4, **d)
 134     1 () {'a': 1, 'b': 2, 'c': 3, 'd': 4}
 135     >>> d == d2
 136     True
 137
 138 What about willful misconduct?
 139
 140     >>> def saboteur(**kw):
 141     ...     kw['x'] = 'm'
 142     ...     return kw
 143
 144     >>> d = {}
 145     >>> kw = saboteur(a=1, **d)
 146     >>> d
 147     {}
 148
 149
 150     >>> g(1, 2, 3, **{'x': 4, 'y': 5})
 151     Traceback (most recent call last):
 152       ...
 153     TypeError: g() got multiple values for keyword argument 'x'
 154
 155     >>> f(**{1:2})
 156     Traceback (most recent call last):
 157       ...
 158     TypeError: f() keywords must be strings
 159
 160     >>> h(**{'e': 2})
 161     Traceback (most recent call last):
 162       ...
 163     TypeError: h() got an unexpected keyword argument 'e'
 164
 165     >>> h(*h)
 166     Traceback (most recent call last):
 167       ...
 168     TypeError: h() argument after * must be a sequence, not function
 169
 170     >>> dir(*h)
 171     Traceback (most recent call last):
 172       ...
 173     TypeError: dir() argument after * must be a sequence, not function
 174
 175     >>> None(*h)
 176     Traceback (most recent call last):
 177       ...
 178     TypeError: NoneType object argument after * must be a sequence, \
 179 not function
 180
 181     >>> h(**h)
 182     Traceback (most recent call last):
 183       ...
 184     TypeError: h() argument after ** must be a mapping, not function
 185
 186     >>> dir(**h)
 187     Traceback (most recent call last):
 188       ...
 189     TypeError: dir() argument after ** must be a mapping, not function
 190
 191     >>> None(**h)
 192     Traceback (most recent call last):
 193       ...
 194     TypeError: NoneType object argument after ** must be a mapping, \
 195 not function
 196
 197     >>> dir(b=1, **{'b': 1})
 198     Traceback (most recent call last):
 199       ...
 200     TypeError: dir() got multiple values for keyword argument 'b'
 201
 202 Another helper function
 203
 204     >>> def f2(*a, **b):
 205     ...     return a, b
 206
 207
 208     >>> d = {}
 209     >>> for i in range(512):
 210     ...     key = 'k%d' % i
 211     ...     d[key] = i
 212     >>> a, b = f2(1, *(2,3), **d)
 213     >>> len(a), len(b), b == d
 214     (3, 512, True)
 215
 216     >>> class Foo:
 217     ...     def method(self, arg1, arg2):
 218     ...         return arg1+arg2
 219
 220     >>> x = Foo()
 221     >>> Foo.method(*(x, 1, 2))
 222     3
 223     >>> Foo.method(x, *(1, 2))
 224     3
 225     >>> Foo.method(*(1, 2, 3))
 226     5
 227     >>> Foo.method(1, *[2, 3])
 228     5
 229
 230 A PyCFunction that takes only positional parameters shoud allow an
 231 empty keyword dictionary to pass without a complaint, but raise a
 232 TypeError if te dictionary is not empty
 233
 234     >>> try:
 235     ...     silence = id(1, *{})
 236     ...     True
 237     ... except:
 238     ...     False
 239     True
 240
 241     >>> id(1, **{'foo': 1})
 242     Traceback (most recent call last):
 243       ...
 244     TypeError: id() takes no keyword arguments
 245
 246 A corner case of keyword dictionary items being deleted during
 247 the function call setup. See <http://bugs.python.org/issue2016>.
 248
 249     >>> class Name(str):
 250     ...     def __eq__(self, other):
 251     ...         try:
 252     ...              del x[self]
 253     ...         except KeyError:
 254     ...              pass
 255     ...         return str.__eq__(self, other)
 256     ...     def __hash__(self):
 257     ...         return str.__hash__(self)
 258
 259     >>> x = {Name("a"):1, Name("b"):2}
 260     >>> def f(a, b):
 261     ...     print(a,b)
 262     >>> f(**x)
 263     1 2
 264 """
 265
 266 from test import support
 267
 268 def test_main():
 269     from test import test_extcall # self import
 270     support.run_doctest(test_extcall, True)
 271
 272 if __name__ == '__main__':
 273     test_main()