2001-01-17 17:51:36 -04:00
|
|
|
from test_support import verify, verbose, TestFailed
|
2000-03-28 19:51:17 -04:00
|
|
|
from UserList import UserList
|
|
|
|
|
2001-01-21 14:52:02 -04:00
|
|
|
def sortdict(d):
|
|
|
|
keys = d.keys()
|
|
|
|
keys.sort()
|
|
|
|
lst = []
|
|
|
|
for k in keys:
|
|
|
|
lst.append("%r: %r" % (k, d[k]))
|
|
|
|
return "{%s}" % ", ".join(lst)
|
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
def f(*a, **k):
|
2001-01-21 14:52:02 -04:00
|
|
|
print a, sortdict(k)
|
2000-03-28 19:51:17 -04:00
|
|
|
|
|
|
|
def g(x, *y, **z):
|
2001-01-21 14:52:02 -04:00
|
|
|
print x, y, sortdict(z)
|
2000-03-28 19:51:17 -04:00
|
|
|
|
|
|
|
def h(j=1, a=2, h=3):
|
|
|
|
print j, a, h
|
|
|
|
|
|
|
|
f()
|
|
|
|
f(1)
|
|
|
|
f(1, 2)
|
|
|
|
f(1, 2, 3)
|
|
|
|
|
|
|
|
f(1, 2, 3, *(4, 5))
|
|
|
|
f(1, 2, 3, *[4, 5])
|
2000-03-28 19:53:22 -04:00
|
|
|
f(1, 2, 3, *UserList([4, 5]))
|
2000-03-28 19:51:17 -04:00
|
|
|
f(1, 2, 3, **{'a':4, 'b':5})
|
|
|
|
f(1, 2, 3, *(4, 5), **{'a':6, 'b':7})
|
|
|
|
f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b':9})
|
|
|
|
|
|
|
|
try:
|
|
|
|
g()
|
|
|
|
except TypeError, err:
|
|
|
|
print "TypeError:", err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: not enough arguments; expected 1, got 0"
|
2000-10-23 14:22:08 -03:00
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
try:
|
|
|
|
g(*())
|
|
|
|
except TypeError, err:
|
|
|
|
print "TypeError:", err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: not enough arguments; expected 1, got 0"
|
2000-10-23 14:22:08 -03:00
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
try:
|
|
|
|
g(*(), **{})
|
|
|
|
except TypeError, err:
|
|
|
|
print "TypeError:", err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: not enough arguments; expected 1, got 0"
|
2000-10-23 14:22:08 -03:00
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
g(1)
|
|
|
|
g(1, 2)
|
|
|
|
g(1, 2, 3)
|
|
|
|
g(1, 2, 3, *(4, 5))
|
2000-03-30 19:55:31 -04:00
|
|
|
class Nothing: pass
|
|
|
|
try:
|
|
|
|
g(*Nothing())
|
|
|
|
except AttributeError, attr:
|
2000-04-10 10:37:14 -03:00
|
|
|
pass
|
2000-03-30 19:55:31 -04:00
|
|
|
else:
|
|
|
|
print "should raise AttributeError: __len__"
|
|
|
|
|
|
|
|
class Nothing:
|
|
|
|
def __len__(self):
|
|
|
|
return 5
|
|
|
|
try:
|
|
|
|
g(*Nothing())
|
|
|
|
except AttributeError, attr:
|
2000-04-10 10:37:14 -03:00
|
|
|
pass
|
2000-03-30 19:55:31 -04:00
|
|
|
else:
|
|
|
|
print "should raise AttributeError: __getitem__"
|
2000-10-23 14:22:08 -03:00
|
|
|
|
2000-03-30 19:55:31 -04:00
|
|
|
class Nothing:
|
|
|
|
def __len__(self):
|
|
|
|
return 5
|
|
|
|
def __getitem__(self, i):
|
|
|
|
if i < 3:
|
|
|
|
return i
|
|
|
|
else:
|
|
|
|
raise IndexError, i
|
|
|
|
g(*Nothing())
|
|
|
|
|
|
|
|
# make sure the function call doesn't stomp on the dictionary?
|
|
|
|
d = {'a': 1, 'b': 2, 'c': 3}
|
|
|
|
d2 = d.copy()
|
2001-01-17 15:11:13 -04:00
|
|
|
verify(d == d2)
|
2000-03-30 19:55:31 -04:00
|
|
|
g(1, d=4, **d)
|
2001-01-21 14:52:02 -04:00
|
|
|
print sortdict(d)
|
|
|
|
print sortdict(d2)
|
2001-01-17 15:11:13 -04:00
|
|
|
verify(d == d2, "function call modified dictionary")
|
2000-03-30 19:55:31 -04:00
|
|
|
|
|
|
|
# what about willful misconduct?
|
|
|
|
def saboteur(**kw):
|
2000-07-14 21:42:09 -03:00
|
|
|
kw['x'] = locals() # yields a cyclic kw
|
|
|
|
return kw
|
2000-03-30 19:55:31 -04:00
|
|
|
d = {}
|
2000-07-14 21:42:09 -03:00
|
|
|
kw = saboteur(a=1, **d)
|
2001-01-17 15:11:13 -04:00
|
|
|
verify(d == {})
|
2000-07-14 21:42:09 -03:00
|
|
|
# break the cycle
|
|
|
|
del kw['x']
|
2000-10-23 14:22:08 -03:00
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
try:
|
|
|
|
g(1, 2, 3, **{'x':4, 'y':5})
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: keyword parameter redefined"
|
2000-10-23 14:22:08 -03:00
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
try:
|
|
|
|
g(1, 2, 3, a=4, b=5, *(6, 7), **{'a':8, 'b':9})
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: keyword parameter redefined"
|
|
|
|
|
|
|
|
try:
|
|
|
|
f(**{1:2})
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: keywords must be strings"
|
|
|
|
|
|
|
|
try:
|
|
|
|
h(**{'e': 2})
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: unexpected keyword argument: e"
|
|
|
|
|
|
|
|
try:
|
|
|
|
h(*h)
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: * argument must be a tuple"
|
|
|
|
|
2001-04-11 10:53:35 -03:00
|
|
|
try:
|
|
|
|
dir(*h)
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: * argument must be a tuple"
|
|
|
|
|
|
|
|
try:
|
|
|
|
None(*h)
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: * argument must be a tuple"
|
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
try:
|
|
|
|
h(**h)
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: ** argument must be a dictionary"
|
|
|
|
|
2001-04-11 10:53:35 -03:00
|
|
|
try:
|
|
|
|
dir(**h)
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: ** argument must be a dictionary"
|
|
|
|
|
|
|
|
try:
|
|
|
|
None(**h)
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: ** argument must be a dictionary"
|
|
|
|
|
|
|
|
try:
|
|
|
|
dir(b=1,**{'b':1})
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
else:
|
|
|
|
print "should raise TypeError: dir() got multiple values for keyword argument 'b'"
|
|
|
|
|
2000-03-28 19:51:17 -04:00
|
|
|
def f2(*a, **b):
|
|
|
|
return a, b
|
|
|
|
|
|
|
|
d = {}
|
|
|
|
for i in range(512):
|
|
|
|
key = 'k%d' % i
|
|
|
|
d[key] = i
|
|
|
|
a, b = f2(1, *(2, 3), **d)
|
|
|
|
print len(a), len(b), b == d
|
2000-10-30 13:15:20 -04:00
|
|
|
|
|
|
|
class Foo:
|
|
|
|
def method(self, arg1, arg2):
|
|
|
|
return arg1 + arg2
|
|
|
|
|
|
|
|
x = Foo()
|
|
|
|
print Foo.method(*(x, 1, 2))
|
|
|
|
print Foo.method(x, *(1, 2))
|
|
|
|
try:
|
|
|
|
print Foo.method(*(1, 2, 3))
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
try:
|
|
|
|
print Foo.method(1, *(2, 3))
|
|
|
|
except TypeError, err:
|
|
|
|
print err
|
|
|
|
|
2001-01-04 18:33:02 -04:00
|
|
|
# A PyCFunction that takes only positional parameters should allow an
|
|
|
|
# empty keyword dictionary to pass without a complaint, but raise a
|
|
|
|
# TypeError if the dictionary is non-empty.
|
|
|
|
id(1, **{})
|
|
|
|
try:
|
|
|
|
id(1, **{"foo": 1})
|
|
|
|
except TypeError:
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
raise TestFailed, 'expected TypeError; no exception raised'
|
2001-01-15 18:14:16 -04:00
|
|
|
|
|
|
|
a, b, d, e, v, k = 'A', 'B', 'D', 'E', 'V', 'K'
|
|
|
|
funcs = []
|
|
|
|
maxargs = {}
|
|
|
|
for args in ['', 'a', 'ab']:
|
|
|
|
for defargs in ['', 'd', 'de']:
|
|
|
|
for vararg in ['', 'v']:
|
|
|
|
for kwarg in ['', 'k']:
|
|
|
|
name = 'z' + args + defargs + vararg + kwarg
|
|
|
|
arglist = list(args) + map(
|
|
|
|
lambda x: '%s="%s"' % (x, x), defargs)
|
|
|
|
if vararg: arglist.append('*' + vararg)
|
|
|
|
if kwarg: arglist.append('**' + kwarg)
|
|
|
|
decl = 'def %s(%s): print "ok %s", a, b, d, e, v, k' % (
|
2001-02-09 07:51:27 -04:00
|
|
|
name, ', '.join(arglist), name)
|
2001-01-15 18:14:16 -04:00
|
|
|
exec(decl)
|
|
|
|
func = eval(name)
|
|
|
|
funcs.append(func)
|
|
|
|
maxargs[func] = len(args + defargs)
|
|
|
|
|
|
|
|
for name in ['za', 'zade', 'zabk', 'zabdv', 'zabdevk']:
|
|
|
|
func = eval(name)
|
|
|
|
for args in [(), (1, 2), (1, 2, 3, 4, 5)]:
|
|
|
|
for kwargs in ['', 'a', 'd', 'ad', 'abde']:
|
|
|
|
kwdict = {}
|
|
|
|
for k in kwargs: kwdict[k] = k + k
|
2001-01-21 14:52:02 -04:00
|
|
|
print func.func_name, args, sortdict(kwdict), '->',
|
2001-01-15 18:14:16 -04:00
|
|
|
try: apply(func, args, kwdict)
|
|
|
|
except TypeError, err: print err
|