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