diff -r 000000000000 -r ae805ac0140d python-2.5.2/win32/Lib/test/test_extcall.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python-2.5.2/win32/Lib/test/test_extcall.py Fri Apr 03 17:19:34 2009 +0100 @@ -0,0 +1,279 @@ +from test.test_support import verify, verbose, TestFailed, sortdict +from UserList import UserList + +def e(a, b): + print a, b + +def f(*a, **k): + print a, sortdict(k) + +def g(x, *y, **z): + print x, y, sortdict(z) + +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]) +f(1, 2, 3, *UserList([4, 5])) +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}) + +# Verify clearing of SF bug #733667 +try: + e(c=3) +except TypeError: + pass +else: + print "should raise TypeError: e() got an unexpected keyword argument 'c'" + +try: + g() +except TypeError, err: + print "TypeError:", err +else: + print "should raise TypeError: not enough arguments; expected 1, got 0" + +try: + g(*()) +except TypeError, err: + print "TypeError:", err +else: + print "should raise TypeError: not enough arguments; expected 1, got 0" + +try: + g(*(), **{}) +except TypeError, err: + print "TypeError:", err +else: + print "should raise TypeError: not enough arguments; expected 1, got 0" + +g(1) +g(1, 2) +g(1, 2, 3) +g(1, 2, 3, *(4, 5)) +class Nothing: pass +try: + g(*Nothing()) +except TypeError, attr: + pass +else: + print "should raise TypeError" + +class Nothing: + def __len__(self): + return 5 +try: + g(*Nothing()) +except TypeError, attr: + pass +else: + print "should raise TypeError" + +class Nothing: + def __len__(self): + return 5 + def __getitem__(self, i): + if i < 3: + return i + else: + raise IndexError, i +g(*Nothing()) + +class Nothing: + def __init__(self): + self.c = 0 + def __iter__(self): + return self +try: + g(*Nothing()) +except TypeError, attr: + pass +else: + print "should raise TypeError" + +class Nothing: + def __init__(self): + self.c = 0 + def __iter__(self): + return self + def next(self): + if self.c == 4: + raise StopIteration + c = self.c + self.c += 1 + return c +g(*Nothing()) + +# make sure the function call doesn't stomp on the dictionary? +d = {'a': 1, 'b': 2, 'c': 3} +d2 = d.copy() +verify(d == d2) +g(1, d=4, **d) +print sortdict(d) +print sortdict(d2) +verify(d == d2, "function call modified dictionary") + +# what about willful misconduct? +def saboteur(**kw): + kw['x'] = locals() # yields a cyclic kw + return kw +d = {} +kw = saboteur(a=1, **d) +verify(d == {}) +# break the cycle +del kw['x'] + +try: + g(1, 2, 3, **{'x':4, 'y':5}) +except TypeError, err: + print err +else: + print "should raise TypeError: keyword parameter redefined" + +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" + +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" + +try: + h(**h) +except TypeError, err: + print err +else: + print "should raise TypeError: ** argument must be a dictionary" + +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'" + +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 + +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: + pass +else: + print 'expected a TypeError for unbound method call' +try: + print Foo.method(1, *(2, 3)) +except TypeError, err: + pass +else: + print 'expected a TypeError for unbound method call' + +# 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' + +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, ' + + 'type(k) is type ("") and k or sortdict(k)') + % (name, ', '.join(arglist), name)) + 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 + print func.func_name, args, sortdict(kwdict), '->', + try: func(*args, **kwdict) + except TypeError, err: print err