test_extcall.py 5.18 KB
Newer Older
1
from test_support import verify, verbose, TestFailed, sortdict
2 3 4
from UserList import UserList

def f(*a, **k):
5
    print a, sortdict(k)
6 7

def g(x, *y, **z):
8
    print x, y, sortdict(z)
9 10 11 12 13 14 15 16 17 18 19

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])
Jeremy Hylton's avatar
Jeremy Hylton committed
20
f(1, 2, 3, *UserList([4, 5]))
21 22 23 24 25 26 27 28 29 30
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"
31

32 33 34 35 36 37
try:
    g(*())
except TypeError, err:
    print "TypeError:", err
else:
    print "should raise TypeError: not enough arguments; expected 1, got 0"
38

39 40 41 42 43 44
try:
    g(*(), **{})
except TypeError, err:
    print "TypeError:", err
else:
    print "should raise TypeError: not enough arguments; expected 1, got 0"
45

46 47 48 49
g(1)
g(1, 2)
g(1, 2, 3)
g(1, 2, 3, *(4, 5))
50 51 52
class Nothing: pass
try:
    g(*Nothing())
53
except TypeError, attr:
54
    pass
55
else:
56
    print "should raise TypeError"
57 58 59 60 61 62

class Nothing:
    def __len__(self):
        return 5
try:
    g(*Nothing())
63
except TypeError, attr:
64
    pass
65
else:
66
    print "should raise TypeError"
67

68 69 70 71 72 73 74 75 76 77 78 79 80
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()
81
verify(d == d2)
82
g(1, d=4, **d)
83 84
print sortdict(d)
print sortdict(d2)
85
verify(d == d2, "function call modified dictionary")
86 87 88

# what about willful misconduct?
def saboteur(**kw):
89 90
    kw['x'] = locals() # yields a cyclic kw
    return kw
91
d = {}
92
kw = saboteur(a=1, **d)
93
verify(d == {})
94 95
# break the cycle
del kw['x']
96

97 98 99 100 101 102
try:
    g(1, 2, 3, **{'x':4, 'y':5})
except TypeError, err:
    print err
else:
    print "should raise TypeError: keyword parameter redefined"
103

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
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"

132 133 134 135 136 137 138 139 140 141 142 143 144 145
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"

146 147 148 149 150 151 152
try:
    h(**h)
except TypeError, err:
    print err
else:
    print "should raise TypeError: ** argument must be a dictionary"

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
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'"

174 175 176 177 178 179 180 181 182
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
Jeremy Hylton's avatar
Jeremy Hylton committed
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

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

200 201 202 203 204 205 206 207 208 209
# 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'
210 211 212 213 214 215 216 217 218 219 220 221 222

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)
223 224 225
                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))
226 227 228 229 230 231 232 233 234 235 236
                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
237
            print func.func_name, args, sortdict(kwdict), '->',
238 239
            try: apply(func, args, kwdict)
            except TypeError, err: print err